@shopify/react-native-skia 2.2.10 → 2.2.12

package/cpp/api/JsiNativeBuffer.h

@@ -36,6 +36,8 @@ public:
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiNativeBufferFactory, Release),
                        JSI_EXPORT_FUNC(JsiNativeBufferFactory, MakeFromImage))
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   explicit JsiNativeBufferFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 };

package/cpp/api/JsiSkAnimatedImage.h

@@ -31,8 +31,10 @@ public:
   // TODO-API: Properties?
   JSI_HOST_FUNCTION(getCurrentFrame) {
     auto image = getObject()->getCurrentFrame();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), std::move(image));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(getFrameCount) {
@@ -60,6 +62,8 @@ public:
                      const sk_sp<SkAnimatedImage> image)
       : JsiSkWrappingSkPtrHostObject<SkAnimatedImage>(std::move(context),
                                                       std::move(image)) {}
+
+  size_t getMemoryPressure() const override { return 8192; }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkAnimatedImageFactory.h

@@ -23,11 +23,14 @@ public:
     if (image == nullptr) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkAnimatedImage>(getContext(), std::move(image)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkAnimatedImage>(getContext(), std::move(image));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkAnimatedImageFactory,
                                        MakeAnimatedImageFromEncoded))
 

package/cpp/api/JsiSkApi.h

@@ -61,6 +61,8 @@ namespace jsi = facebook::jsi;
 
 class JsiSkApi : public JsiSkHostObject {
 public:
+  size_t getMemoryPressure() const override { return 8192; }
+
   /**
    * Constructs the Skia Api object that can be installed into a runtime
    * and provide functions for accessing and creating the Skia wrapper objects

package/cpp/api/JsiSkCanvas.h

@@ -681,6 +681,8 @@ public:
                        JSI_EXPORT_FUNC(JsiSkCanvas, drawAtlas),
                        JSI_EXPORT_FUNC(JsiSkCanvas, readPixels))
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   explicit JsiSkCanvas(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 

package/cpp/api/JsiSkColorFilter.h

@@ -23,6 +23,8 @@ public:
       : JsiSkWrappingSkPtrHostObject<SkColorFilter>(std::move(context),
                                                     std::move(colorFilter)) {}
 
+  size_t getMemoryPressure() const override { return 2048; }
+
   EXPORT_JSI_API_TYPENAME(JsiSkColorFilter, ColorFilter)
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkColorFilter, dispose))
 };

package/cpp/api/JsiSkColorFilterFactory.h

@@ -30,28 +30,31 @@ public:
       }
     }
     // Return the newly constructed object
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::Matrix(std::move(matrix))));
+    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::Matrix(std::move(matrix)));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeBlend) {
     auto color = JsiSkColor::fromValue(runtime, arguments[0]);
     SkBlendMode blend = (SkBlendMode)arguments[1].asNumber();
     // Return the newly constructed object
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::Blend(color, blend)));
+    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::Blend(color, blend));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeCompose) {
     auto outer = JsiSkColorFilter::fromValue(runtime, arguments[0]);
     auto inner = JsiSkColorFilter::fromValue(runtime, arguments[1]);
     // Return the newly constructed object
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::Compose(std::move(outer),
-                                                           std::move(inner))));
+    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+        getContext(),
+        SkColorFilters::Compose(std::move(outer), std::move(inner)));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeLerp) {
@@ -59,33 +62,38 @@ public:
     auto dst = JsiSkColorFilter::fromValue(runtime, arguments[1]);
     auto src = JsiSkColorFilter::fromValue(runtime, arguments[2]);
     // Return the newly constructed object
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(),
-                     SkColorFilters::Lerp(t, std::move(dst), std::move(src))));
+    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::Lerp(t, std::move(dst), std::move(src)));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeSRGBToLinearGamma) {
     // Return the newly constructed object
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::SRGBToLinearGamma()));
+    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::SRGBToLinearGamma());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeLinearToSRGBGamma) {
     // Return the newly constructed object
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkColorFilter>(
-                     getContext(), SkColorFilters::LinearToSRGBGamma()));
+    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+        getContext(), SkColorFilters::LinearToSRGBGamma());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeLumaColorFilter) {
     // Return the newly constructed object
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkColorFilter>(getContext(),
-                                                    SkLumaColorFilter::Make()));
+    auto colorFilter = std::make_shared<JsiSkColorFilter>(
+        getContext(), SkLumaColorFilter::Make());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, colorFilter,
+                                                       getContext());
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   JSI_EXPORT_FUNCTIONS(
       JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeMatrix),
       JSI_EXPORT_FUNC(JsiSkColorFilterFactory, MakeBlend),

package/cpp/api/JsiSkContourMeasure.h

@@ -37,10 +37,12 @@ public:
       throw jsi::JSError(runtime, "getPosTan() failed");
     }
     auto posTan = jsi::Array(runtime, 2);
-    auto pos = jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPoint>(getContext(), position));
-    auto tan = jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkPoint>(getContext(), tangent));
+    auto posPoint = std::make_shared<JsiSkPoint>(getContext(), position);
+    auto pos = JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, posPoint,
+                                                           getContext());
+    auto tanPoint = std::make_shared<JsiSkPoint>(getContext(), tangent);
+    auto tan = JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, tanPoint,
+                                                           getContext());
     posTan.setValueAtIndex(runtime, 0, pos);
     posTan.setValueAtIndex(runtime, 1, tan);
     return posTan;
@@ -64,6 +66,8 @@ public:
     return JsiSkPath::toValue(runtime, getContext(), std::move(path));
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   EXPORT_JSI_API_TYPENAME(JsiSkContourMeasure, ContourMeasure)
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasure, getPosTan),

package/cpp/api/JsiSkContourMeasureIter.h

@@ -37,7 +37,8 @@ public:
     auto nextObject =
         std::make_shared<JsiSkContourMeasure>(getContext(), std::move(next));
 
-    return jsi::Object::createFromHostObject(runtime, std::move(nextObject));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, nextObject,
+                                                       getContext());
   }
 
   EXPORT_JSI_API_TYPENAME(JsiSkContourMeasureIter, ContourMeasureIter)
@@ -45,6 +46,10 @@ public:
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkContourMeasureIter, next),
                        JSI_EXPORT_FUNC(JsiSkContourMeasureIter, dispose))
 
+  size_t getMemoryPressure() const override {
+    return sizeof(SkContourMeasureIter);
+  }
+
   /**
    * Creates the function for construction a new instance of the
    * SkContourMeasureIter wrapper
@@ -59,9 +64,10 @@ public:
       auto forceClosed = arguments[1].getBool();
       auto resScale = arguments[2].asNumber();
       // Return the newly constructed object
-      return jsi::Object::createFromHostObject(
-          runtime, std::make_shared<JsiSkContourMeasureIter>(
-                       std::move(context), *path, forceClosed, resScale));
+      auto iter = std::make_shared<JsiSkContourMeasureIter>(
+          std::move(context), *path, forceClosed, resScale);
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, iter,
+                                                         context);
     };
   }
 };

package/cpp/api/JsiSkData.h

@@ -24,6 +24,11 @@ public:
   JsiSkData(std::shared_ptr<RNSkPlatformContext> context, sk_sp<SkData> asset)
       : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(asset)) {}
 
+  size_t getMemoryPressure() const override {
+    auto data = getObject();
+    return data ? data->size() : 0;
+  }
+
   EXPORT_JSI_API_TYPENAME(JsiSkData, Data)
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkData, dispose))
 };

package/cpp/api/JsiSkDataFactory.h

@@ -38,9 +38,10 @@ public:
                                                 context = std::move(context),
                                                 promise = std::move(promise),
                                                 result = std::move(result)]() {
-                  promise->resolve(jsi::Object::createFromHostObject(
-                      runtime, std::make_shared<JsiSkData>(std::move(context),
-                                                           std::move(result))));
+                  auto hostObjectInstance =
+                      std::make_shared<JsiSkData>(context, std::move(result));
+                  promise->resolve(JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+                      runtime, hostObjectInstance, context));
                 });
               });
         });
@@ -55,8 +56,10 @@ public:
 
     auto data =
         SkData::MakeWithCopy(buffer.data(runtime), buffer.size(runtime));
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkData>(getContext(), std::move(data)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkData>(getContext(), std::move(data));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(fromBase64) {
@@ -82,10 +85,14 @@ public:
       return jsi::Value::undefined();
     }
 
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkData>(getContext(), std::move(data)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkData>(getContext(), std::move(data));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkDataFactory, fromURI),
                        JSI_EXPORT_FUNC(JsiSkDataFactory, fromBytes),
                        JSI_EXPORT_FUNC(JsiSkDataFactory, fromBase64))

package/cpp/api/JsiSkFont.h

@@ -91,8 +91,9 @@ public:
       getObject()->measureText(str.c_str(), str.length(), SkTextEncoding::kUTF8,
                                &bounds);
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkRect>(getContext(), std::move(bounds)));
+    auto rect = std::make_shared<JsiSkRect>(getContext(), std::move(bounds));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, rect,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(getMetrics) {
@@ -278,6 +279,8 @@ public:
       : JsiSkWrappingSharedPtrHostObject(std::move(context),
                                          std::make_shared<SkFont>(font)) {}
 
+  size_t getMemoryPressure() const override { return sizeof(SkFont); }
+
   /**
    * Creates the function for construction a new instance of the SkFont
    * wrapper
@@ -292,18 +295,22 @@ public:
       if (count == 2) {
         auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
         auto size = arguments[1].asNumber();
-        return jsi::Object::createFromHostObject(
-            runtime, std::make_shared<JsiSkFont>(std::move(context),
-                                                 SkFont(typeface, size)));
+        auto hostObjectInstance =
+            std::make_shared<JsiSkFont>(context, SkFont(typeface, size));
+        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+            runtime, hostObjectInstance, std::move(context));
       } else if (count == 1) {
         auto typeface = JsiSkTypeface::fromValue(runtime, arguments[0]);
-        return jsi::Object::createFromHostObject(
-            runtime,
-            std::make_shared<JsiSkFont>(std::move(context), SkFont(typeface)));
+        auto hostObjectInstance =
+            std::make_shared<JsiSkFont>(context, SkFont(typeface));
+        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+            runtime, hostObjectInstance, std::move(context));
       } else {
         // Return the newly constructed object
-        return jsi::Object::createFromHostObject(
-            runtime, std::make_shared<JsiSkFont>(std::move(context), SkFont()));
+        auto hostObjectInstance =
+            std::make_shared<JsiSkFont>(context, SkFont());
+        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+            runtime, hostObjectInstance, std::move(context));
       }
     };
   }

package/cpp/api/JsiSkFontMgr.h

@@ -42,10 +42,14 @@ public:
     auto name = arguments[0].asString(runtime).utf8(runtime);
     auto fontStyle = JsiSkFontStyle::fromValue(runtime, arguments[1]);
     auto typeface = getObject()->matchFamilyStyle(name.c_str(), *fontStyle);
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
+  size_t getMemoryPressure() const override { return 2048; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgr, countFamilies),
                        JSI_EXPORT_FUNC(JsiSkFontMgr, getFamilyName),
                        JSI_EXPORT_FUNC(JsiSkFontMgr, matchFamilyStyle))

package/cpp/api/JsiSkFontMgrFactory.h

@@ -32,12 +32,15 @@ public:
 
   JSI_HOST_FUNCTION(System) {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkFontMgr>(getContext(), fontMgr));
+    auto fontMgrObj = std::make_shared<JsiSkFontMgr>(getContext(), fontMgr);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontMgrObj,
+                                                       getContext());
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgrFactory, System))
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   explicit JsiSkFontMgrFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 };

package/cpp/api/JsiSkFontStyle.h

@@ -56,15 +56,18 @@ public:
     }
   }
 
+  size_t getMemoryPressure() const override { return sizeof(SkFontStyle); }
+
   /**
   Returns the jsi object from a host object of this type
  */
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkFontStyle &fontStyle) {
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkFontStyle>(std::move(context), fontStyle));
+    auto fontStyleObj =
+        std::make_shared<JsiSkFontStyle>(std::move(context), fontStyle);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontStyleObj,
+                                                       context);
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkHostObjects.h

@@ -23,6 +23,12 @@ public:
   explicit JsiSkHostObject(std::shared_ptr<RNSkPlatformContext> context)
       : _context(context) {}
 
+  /**
+   * Override this method to return the memory pressure for the wrapped object.
+   * @return The memory pressure in bytes
+   */
+  virtual size_t getMemoryPressure() const = 0;
+
 protected:
   /**
    * @return A pointer to the platform context
@@ -42,6 +48,18 @@ private:
   JSI_API_TYPENAME(TYPENAME)                                                   \
   JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(CLASS, __typename__))
 
+#define JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(                           \
+    runtime, hostObjectInstance, context)                                      \
+  [&]() {                                                                      \
+    auto result =                                                              \
+        jsi::Object::createFromHostObject(runtime, hostObjectInstance);        \
+    auto memoryPressure = hostObjectInstance->getMemoryPressure();             \
+    if (memoryPressure > 0) {                                                  \
+      result.setExternalMemoryPressure(runtime, memoryPressure);               \
+    }                                                                          \
+    return result;                                                             \
+  }()
+
 template <typename T> class JsiSkWrappingHostObject : public JsiSkHostObject {
 public:
   /**
@@ -58,8 +76,8 @@ public:
    * Throws if the object has been disposed.
    * @return Underlying object
    */
-  T getObject() { return validateObject(); }
-  const T getObject() const { return validateObject(); }
+  T getObject() { return _object; }
+  const T getObject() const { return _object; }
 
   /**
    * Updates the inner object with a new version of the object.
@@ -71,44 +89,15 @@ public:
    * macro.
    */
   JSI_HOST_FUNCTION(dispose) {
-    safeDispose();
+    // This is a no-op on native
     return jsi::Value::undefined();
   }
 
-protected:
-  /**
-   * Override to implement disposal of allocated resources like smart pointers.
-   * This method will only be called once for each instance of this class.
-   */
-  virtual void releaseResources() = 0;
-
 private:
-  /**
-   * Validates that _object was not disposed and returns it.
-   */
-  T validateObject() const {
-    if (_isDisposed) {
-      throw std::runtime_error("Attempted to access a disposed object.");
-    }
-    return _object;
-  }
-
-  void safeDispose() {
-    if (!_isDisposed) {
-      _isDisposed = true;
-      releaseResources();
-    }
-  }
-
   /**
    * Wrapped object.
    */
   T _object;
-
-  /**
-   * Resource disposed flag.
-   */
-  std::atomic<bool> _isDisposed = {false};
 };
 
 template <typename T>
@@ -129,12 +118,6 @@ public:
                obj.asObject(runtime).asHostObject(runtime))
         ->getObject();
   }
-
-protected:
-  void releaseResources() override {
-    // Clear internally allocated objects
-    this->setObject(nullptr);
-  }
 };
 
 template <typename T>
@@ -153,12 +136,6 @@ public:
                obj.asObject(runtime).asHostObject(runtime))
         ->getObject();
   }
-
-protected:
-  void releaseResources() override {
-    // Clear internally allocated objects
-    this->setObject(nullptr);
-  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -83,9 +83,10 @@ public:
                  : nullptr;
     auto shader =
         getObject()->makeShader(tmx, tmy, SkSamplingOptions(fm, mm), m);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    auto shaderObj =
+        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(makeShaderCubic) {
@@ -98,9 +99,10 @@ public:
                  : nullptr;
     auto shader =
         getObject()->makeShader(tmx, tmy, SkSamplingOptions({B, C}), m);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    auto shaderObj =
+        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
+                                                       getContext());
   }
 
   sk_sp<SkData> encodeImageData(const jsi::Value *arguments, size_t count) {
@@ -237,8 +239,10 @@ public:
     auto grContext = getContext()->getDirectContext();
     auto rasterImage = getObject()->makeRasterImage(grContext);
 #endif
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), rasterImage));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), std::move(rasterImage));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(getNativeTextureUnstable) {
@@ -268,6 +272,11 @@ public:
              const sk_sp<SkImage> image)
       : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context),
                                               std::move(image)) {}
+
+  size_t getMemoryPressure() const override {
+    auto image = getObject();
+    return image ? image->imageInfo().computeMinByteSize() : 0;
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkImageFactory.h

@@ -18,8 +18,10 @@ namespace jsi = facebook::jsi;
 class JsiSkImageFactory : public JsiSkHostObject {
 public:
   JSI_HOST_FUNCTION(MakeNull) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), nullptr));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), nullptr);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeImageFromEncoded) {
@@ -28,8 +30,10 @@ public:
     if (image == nullptr) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), std::move(image));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeImageFromNativeBuffer) {
@@ -40,8 +44,10 @@ public:
     if (image == nullptr) {
       throw std::runtime_error("Failed to convert NativeBuffer to SkImage!");
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), std::move(image));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeImage) {
@@ -52,8 +58,10 @@ public:
     if (image == nullptr) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), std::move(image));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeImageFromViewTag) {
@@ -75,9 +83,10 @@ public:
                     promise->reject("Failed to create image from view tag");
                     return;
                   }
-                  promise->resolve(jsi::Object::createFromHostObject(
-                      runtime, std::make_shared<JsiSkImage>(
-                                   std::move(context), std::move(result))));
+                  auto hostObjectInstance =
+                      std::make_shared<JsiSkImage>(context, std::move(result));
+                  promise->resolve(JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+                      runtime, hostObjectInstance, context));
                 });
               });
         });
@@ -98,10 +107,14 @@ public:
       jsiImage->setObject(image);
       return jsi::Value(runtime, arguments[4]);
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), std::move(image));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromEncoded),
                        JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromViewTag),
                        JSI_EXPORT_FUNC(JsiSkImageFactory,