@shopify/react-native-skia 2.13.0 → 2.14.0

package/cpp/api/JsiSkPath.h

@@ -3,7 +3,6 @@
 #include <algorithm>
 #include <memory>
 #include <optional>
-#include <set>
 #include <string>
 #include <utility>
 #include <variant>
@@ -41,29 +40,6 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-// Track which deprecation warnings have been shown to avoid spam
-inline std::set<std::string> &getShownPathDeprecationWarnings() {
-  static std::set<std::string> warnings;
-  return warnings;
-}
-
-inline void warnDeprecatedPathMethod(jsi::Runtime &runtime,
-                                     const char *methodName,
-                                     const char *suggestion) {
-  auto &warnings = getShownPathDeprecationWarnings();
-  if (warnings.find(methodName) != warnings.end()) {
-    return;
-  }
-  warnings.insert(methodName);
-  std::string message =
-      std::string("[react-native-skia] SkPath.") + methodName +
-      "() is deprecated and will be removed in a future release. " +
-      suggestion +
-      " See migration guide: "
-      "https://shopify.github.io/react-native-skia/docs/shapes/path-migration";
-  RNSkLogger::warnToJavascriptConsole(runtime, message);
-}
-
 class JsiSkPath
     : public JsiSkWrappingSharedPtrNativeObject<JsiSkPath, SkPathBuilder> {
 public:
@@ -80,343 +56,6 @@ private:
   SkPath asPath() const { return getObject()->snapshot(); }
 
 public:
-  // Mutable building methods (deprecated) — chainable, and they take the
-  // runtime for the JS console deprecation warning.
-
-  void moveTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "moveTo",
-                             "Use Skia.PathBuilder.Make().moveTo() instead.");
-    getObject()->moveTo(x, y);
-  }
-
-  void rMoveTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "rMoveTo",
-                             "Use Skia.PathBuilder.Make().rMoveTo() instead.");
-    getObject()->rMoveTo({static_cast<SkScalar>(x), static_cast<SkScalar>(y)});
-  }
-
-  void lineTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "lineTo",
-                             "Use Skia.PathBuilder.Make().lineTo() instead.");
-    getObject()->lineTo(x, y);
-  }
-
-  void rLineTo(jsi::Runtime &runtime, double x, double y) {
-    warnDeprecatedPathMethod(runtime, "rLineTo",
-                             "Use Skia.PathBuilder.Make().rLineTo() instead.");
-    getObject()->rLineTo(x, y);
-  }
-
-  void quadTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-              double y2) {
-    warnDeprecatedPathMethod(runtime, "quadTo",
-                             "Use Skia.PathBuilder.Make().quadTo() instead.");
-    getObject()->quadTo(x1, y1, x2, y2);
-  }
-
-  void rQuadTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-               double y2) {
-    warnDeprecatedPathMethod(runtime, "rQuadTo",
-                             "Use Skia.PathBuilder.Make().rQuadTo() instead.");
-    getObject()->rQuadTo(x1, y1, x2, y2);
-  }
-
-  void conicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-               double y2, double w) {
-    warnDeprecatedPathMethod(runtime, "conicTo",
-                             "Use Skia.PathBuilder.Make().conicTo() instead.");
-    getObject()->conicTo(x1, y1, x2, y2, w);
-  }
-
-  void rConicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-                double y2, double w) {
-    warnDeprecatedPathMethod(runtime, "rConicTo",
-                             "Use Skia.PathBuilder.Make().rConicTo() instead.");
-    getObject()->rConicTo(x1, y1, x2, y2, w);
-  }
-
-  void cubicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-               double y2, double x3, double y3) {
-    warnDeprecatedPathMethod(runtime, "cubicTo",
-                             "Use Skia.PathBuilder.Make().cubicTo() instead.");
-    getObject()->cubicTo(x1, y1, x2, y2, x3, y3);
-  }
-
-  void rCubicTo(jsi::Runtime &runtime, double x1, double y1, double x2,
-                double y2, double x3, double y3) {
-    warnDeprecatedPathMethod(runtime, "rCubicTo",
-                             "Use Skia.PathBuilder.Make().rCubicTo() instead.");
-    getObject()->rCubicTo(x1, y1, x2, y2, x3, y3);
-  }
-
-  void close(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "close",
-                             "Use Skia.PathBuilder.Make().close() instead.");
-    getObject()->close();
-  }
-
-  void reset(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "reset",
-                             "Use Skia.PathBuilder.Make().reset() instead.");
-    getObject()->reset();
-  }
-
-  void rewind(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "rewind",
-                             "Use Skia.PathBuilder.Make().reset() instead.");
-    getObject()->reset();
-  }
-
-  void addPath(jsi::Runtime &runtime, std::shared_ptr<SkPathBuilder> src,
-               JsiOptional<std::shared_ptr<SkMatrix>> matrix,
-               JsiOptional<bool> extend) {
-    warnDeprecatedPathMethod(runtime, "addPath",
-                             "Use Skia.PathBuilder.Make().addPath() instead.");
-    auto srcPath = src->snapshot();
-    auto mode = extend.has_value() && *extend ? SkPath::kExtend_AddPathMode
-                                              : SkPath::kAppend_AddPathMode;
-    if (matrix.has_value()) {
-      getObject()->addPath(srcPath, **matrix, mode);
-    } else {
-      getObject()->addPath(srcPath, mode);
-    }
-  }
-
-  void addArc(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-              double start, double sweep) {
-    warnDeprecatedPathMethod(runtime, "addArc",
-                             "Use Skia.PathBuilder.Make().addArc() instead.");
-    getObject()->addArc(*rect, start, sweep);
-  }
-
-  void addOval(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-               JsiOptional<bool> isCCW, JsiOptional<double> startIndex) {
-    warnDeprecatedPathMethod(
-        runtime, "addOval",
-        "Use Skia.Path.Oval() or Skia.PathBuilder.Make().addOval() instead.");
-    getObject()->addOval(*rect, toDirection(isCCW),
-                         startIndex.has_value()
-                             ? static_cast<unsigned>(*startIndex)
-                             : 1);
-  }
-
-  void addRect(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-               JsiOptional<bool> isCCW) {
-    warnDeprecatedPathMethod(
-        runtime, "addRect",
-        "Use Skia.Path.Rect() or Skia.PathBuilder.Make().addRect() instead.");
-    getObject()->addRect(*rect, toDirection(isCCW));
-  }
-
-  void addRRect(jsi::Runtime &runtime, std::shared_ptr<SkRRect> rrect,
-                JsiOptional<bool> isCCW) {
-    warnDeprecatedPathMethod(
-        runtime, "addRRect",
-        "Use Skia.Path.RRect() or Skia.PathBuilder.Make().addRRect() instead.");
-    getObject()->addRRect(*rrect, toDirection(isCCW));
-  }
-
-  void addCircle(jsi::Runtime &runtime, double x, double y, double r) {
-    warnDeprecatedPathMethod(
-        runtime, "addCircle",
-        "Use Skia.Path.Circle() or Skia.PathBuilder.Make().addCircle() "
-        "instead.");
-    getObject()->addCircle(x, y, r);
-  }
-
-  void addPoly(jsi::Runtime &runtime, std::vector<SkPoint> points,
-               bool close) {
-    warnDeprecatedPathMethod(
-        runtime, "addPoly",
-        "Use Skia.Path.Polygon() or Skia.PathBuilder.Make().addPoly() "
-        "instead.");
-    getObject()->addPolygon(SkSpan<const SkPoint>(points.data(), points.size()),
-                            close);
-  }
-
-  void arcToOval(jsi::Runtime &runtime, std::shared_ptr<SkRect> rect,
-                 double start, double sweep, bool forceMoveTo) {
-    warnDeprecatedPathMethod(
-        runtime, "arcToOval",
-        "Use Skia.PathBuilder.Make().arcToOval() instead.");
-    getObject()->arcTo(*rect, start, sweep, forceMoveTo);
-  }
-
-  void arcToRotated(jsi::Runtime &runtime, double rx, double ry,
-                    double xAxisRotate, bool useSmallArc, bool isCCW, double x,
-                    double y) {
-    warnDeprecatedPathMethod(
-        runtime, "arcToRotated",
-        "Use Skia.PathBuilder.Make().arcToRotated() instead.");
-    auto arcSize = useSmallArc ? SkPathBuilder::kSmall_ArcSize
-                               : SkPathBuilder::kLarge_ArcSize;
-    auto sweep = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
-    getObject()->arcTo(SkPoint::Make(rx, ry), xAxisRotate, arcSize, sweep,
-                       SkPoint::Make(x, y));
-  }
-
-  void rArcTo(jsi::Runtime &runtime, double rx, double ry, double xAxisRotate,
-              bool useSmallArc, bool isCCW, double dx, double dy) {
-    warnDeprecatedPathMethod(runtime, "rArcTo",
-                             "Use Skia.PathBuilder.Make().rArcTo() instead.");
-    auto arcSize = useSmallArc ? SkPathBuilder::kSmall_ArcSize
-                               : SkPathBuilder::kLarge_ArcSize;
-    auto sweep = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
-    SkVector dxdy(dx, dy);
-    SkPoint r(rx, ry);
-    getObject()->rArcTo(r, xAxisRotate, arcSize, sweep, dxdy);
-  }
-
-  void arcToTangent(jsi::Runtime &runtime, double x1, double y1, double x2,
-                    double y2, double r) {
-    warnDeprecatedPathMethod(
-        runtime, "arcToTangent",
-        "Use Skia.PathBuilder.Make().arcToTangent() instead.");
-    getObject()->arcTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2), r);
-  }
-
-  void setFillType(jsi::Runtime &runtime, double ft) {
-    warnDeprecatedPathMethod(
-        runtime, "setFillType",
-        "Use Skia.PathBuilder.Make().setFillType() instead.");
-    getObject()->setFillType(static_cast<SkPathFillType>(static_cast<int>(ft)));
-  }
-
-  void setIsVolatile(jsi::Runtime &runtime, bool v) {
-    warnDeprecatedPathMethod(
-        runtime, "setIsVolatile",
-        "Use Skia.PathBuilder.Make().setIsVolatile() instead.");
-    getObject()->setIsVolatile(v);
-  }
-
-  // Mutable transform methods (deprecated)
-
-  void transform(jsi::Runtime &runtime, std::shared_ptr<SkMatrix> m3) {
-    warnDeprecatedPathMethod(
-        runtime, "transform",
-        "Use Skia.PathBuilder.Make().transform() instead.");
-    getObject()->transform(*m3);
-  }
-
-  void offset(jsi::Runtime &runtime, double dx, double dy) {
-    warnDeprecatedPathMethod(runtime, "offset",
-                             "Use Skia.PathBuilder.Make().offset() instead.");
-    getObject()->offset(dx, dy);
-  }
-
-  // Mutable path operations (deprecated)
-
-  void simplify(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "simplify",
-                             "Use Skia.Path.Simplify(path) instead.");
-    auto path = asPath();
-    auto result = ::Simplify(path);
-    if (result.has_value()) {
-      *getObject() = SkPathBuilder(result.value());
-    }
-  }
-
-  void op(jsi::Runtime &runtime, std::shared_ptr<SkPathBuilder> path2,
-          double pathOp) {
-    warnDeprecatedPathMethod(runtime, "op",
-                             "Use Skia.Path.MakeFromOp() instead.");
-    auto p1 = asPath();
-    auto p2 = path2->snapshot();
-    auto result =
-        ::Op(p1, p2, static_cast<SkPathOp>(static_cast<int>(pathOp)));
-    if (result.has_value()) {
-      *getObject() = SkPathBuilder(result.value());
-    }
-  }
-
-  void makeAsWinding(jsi::Runtime &runtime) {
-    warnDeprecatedPathMethod(runtime, "makeAsWinding",
-                             "Use Skia.Path.AsWinding(path) instead.");
-    auto path = asPath();
-    auto result = ::AsWinding(path);
-    if (result.has_value()) {
-      *getObject() = SkPathBuilder(result.value());
-    }
-  }
-
-  void dash(jsi::Runtime &runtime, double on, double off, double phase) {
-    warnDeprecatedPathMethod(
-        runtime, "dash", "Use Skia.Path.Dash(path, on, off, phase) instead.");
-    auto path = asPath();
-    SkScalar intervals[] = {static_cast<SkScalar>(on),
-                            static_cast<SkScalar>(off)};
-    auto pe = SkDashPathEffect::Make(SkSpan(intervals, 2), phase);
-    if (pe) {
-      SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
-      SkPathBuilder resultBuilder;
-      if (pe->filterPath(&resultBuilder, path, &rec)) {
-        *getObject() = std::move(resultBuilder);
-      }
-    }
-  }
-
-  // Stays raw: the options object is read leniently property by property.
-  JSI_HOST_FUNCTION(stroke) {
-    warnDeprecatedPathMethod(runtime, "stroke",
-                             "Use Skia.Path.Stroke(path, opts) instead.");
-    auto path = asPath();
-    SkPaint p;
-    p.setStyle(SkPaint::kStroke_Style);
-
-    if (count > 0 && !arguments[0].isUndefined()) {
-      auto opts = arguments[0].asObject(runtime);
-
-      auto jsiCap = opts.getProperty(runtime, "cap");
-      if (!jsiCap.isUndefined()) {
-        p.setStrokeCap(
-            static_cast<SkPaint::Cap>(static_cast<int>(jsiCap.asNumber())));
-      }
-
-      auto jsiJoin = opts.getProperty(runtime, "join");
-      if (!jsiJoin.isUndefined()) {
-        p.setStrokeJoin(
-            static_cast<SkPaint::Join>(static_cast<int>(jsiJoin.asNumber())));
-      }
-
-      auto jsiWidth = opts.getProperty(runtime, "width");
-      if (!jsiWidth.isUndefined()) {
-        p.setStrokeWidth(jsiWidth.asNumber());
-      }
-
-      auto jsiMiterLimit = opts.getProperty(runtime, "miter_limit");
-      if (!jsiMiterLimit.isUndefined()) {
-        p.setStrokeMiter(jsiMiterLimit.asNumber());
-      }
-    }
-
-    SkPathBuilder resultBuilder;
-    auto success = skpathutils::FillPathWithPaint(path, p, &resultBuilder);
-    if (success) {
-      *getObject() = std::move(resultBuilder);
-    }
-    return thisValue.getObject(runtime);
-  }
-
-  void trim(jsi::Runtime &runtime, double startValue, double endValue,
-            bool isComplement) {
-    warnDeprecatedPathMethod(
-        runtime, "trim",
-        "Use Skia.Path.Trim(path, start, end, isComplement) instead.");
-    auto path = asPath();
-    float start = std::clamp(static_cast<float>(startValue), 0.0f, 1.0f);
-    float end = std::clamp(static_cast<float>(endValue), 0.0f, 1.0f);
-    auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted
-                             : SkTrimPathEffect::Mode::kNormal;
-    auto pe = SkTrimPathEffect::Make(start, end, mode);
-    if (pe) {
-      SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
-      SkPathBuilder resultBuilder;
-      if (pe->filterPath(&resultBuilder, path, &rec)) {
-        *getObject() = std::move(resultBuilder);
-      }
-    }
-  }
-
   // Query methods
 
   std::shared_ptr<JsiSkRect> computeTightBounds() {
@@ -540,76 +179,6 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    // Mutable building methods
-    installChainableMethodWithRuntime(runtime, prototype, "moveTo",
-                                      &JsiSkPath::moveTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rMoveTo",
-                                      &JsiSkPath::rMoveTo);
-    installChainableMethodWithRuntime(runtime, prototype, "lineTo",
-                                      &JsiSkPath::lineTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rLineTo",
-                                      &JsiSkPath::rLineTo);
-    installChainableMethodWithRuntime(runtime, prototype, "quadTo",
-                                      &JsiSkPath::quadTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rQuadTo",
-                                      &JsiSkPath::rQuadTo);
-    installChainableMethodWithRuntime(runtime, prototype, "conicTo",
-                                      &JsiSkPath::conicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rConicTo",
-                                      &JsiSkPath::rConicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "cubicTo",
-                                      &JsiSkPath::cubicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "rCubicTo",
-                                      &JsiSkPath::rCubicTo);
-    installChainableMethodWithRuntime(runtime, prototype, "close",
-                                      &JsiSkPath::close);
-    installChainableMethodWithRuntime(runtime, prototype, "reset",
-                                      &JsiSkPath::reset);
-    installChainableMethodWithRuntime(runtime, prototype, "rewind",
-                                      &JsiSkPath::rewind);
-    installChainableMethodWithRuntime(runtime, prototype, "addPath",
-                                      &JsiSkPath::addPath);
-    installChainableMethodWithRuntime(runtime, prototype, "addArc",
-                                      &JsiSkPath::addArc);
-    installChainableMethodWithRuntime(runtime, prototype, "addOval",
-                                      &JsiSkPath::addOval);
-    installChainableMethodWithRuntime(runtime, prototype, "addRect",
-                                      &JsiSkPath::addRect);
-    installChainableMethodWithRuntime(runtime, prototype, "addRRect",
-                                      &JsiSkPath::addRRect);
-    installChainableMethodWithRuntime(runtime, prototype, "addCircle",
-                                      &JsiSkPath::addCircle);
-    installChainableMethodWithRuntime(runtime, prototype, "addPoly",
-                                      &JsiSkPath::addPoly);
-    installChainableMethodWithRuntime(runtime, prototype, "arcToOval",
-                                      &JsiSkPath::arcToOval);
-    installChainableMethodWithRuntime(runtime, prototype, "arcToRotated",
-                                      &JsiSkPath::arcToRotated);
-    installChainableMethodWithRuntime(runtime, prototype, "rArcTo",
-                                      &JsiSkPath::rArcTo);
-    installChainableMethodWithRuntime(runtime, prototype, "arcToTangent",
-                                      &JsiSkPath::arcToTangent);
-    installChainableMethodWithRuntime(runtime, prototype, "setFillType",
-                                      &JsiSkPath::setFillType);
-    installChainableMethodWithRuntime(runtime, prototype, "setIsVolatile",
-                                      &JsiSkPath::setIsVolatile);
-    // Mutable transform methods
-    installChainableMethodWithRuntime(runtime, prototype, "transform",
-                                      &JsiSkPath::transform);
-    installChainableMethodWithRuntime(runtime, prototype, "offset",
-                                      &JsiSkPath::offset);
-    // Mutable path operations
-    installChainableMethodWithRuntime(runtime, prototype, "simplify",
-                                      &JsiSkPath::simplify);
-    installChainableMethodWithRuntime(runtime, prototype, "op",
-                                      &JsiSkPath::op);
-    installChainableMethodWithRuntime(runtime, prototype, "makeAsWinding",
-                                      &JsiSkPath::makeAsWinding);
-    installChainableMethodWithRuntime(runtime, prototype, "dash",
-                                      &JsiSkPath::dash);
-    installHostMethod(runtime, prototype, "stroke", &JsiSkPath::stroke);
-    installChainableMethodWithRuntime(runtime, prototype, "trim",
-                                      &JsiSkPath::trim);
     // Query methods
     installMethod(runtime, prototype, "computeTightBounds",
                   &JsiSkPath::computeTightBounds);
@@ -640,11 +209,18 @@ public:
       : JsiSkPath(std::move(context), SkPathBuilder(path)) {}
 
   size_t getMemoryPressure() override {
-    auto builder = getObject();
-    if (!builder)
+    if (isDisposed()) {
       return 0;
-
-    return builder->snapshot().approximateBytesUsed();
+    }
+    auto builder = getObjectUnchecked();
+    if (!builder) {
+      return 0;
+    }
+    // The point, verb and conic weight arrays of the builder. Snapshotting
+    // the path to measure it would copy them, and this runs on every round
+    // trip of the object to JS.
+    return builder->points().size_bytes() + builder->verbs().size_bytes() +
+           builder->conicWeights().size_bytes();
   }
 
   /**

package/cpp/api/JsiSkPathBuilder.h

@@ -271,11 +271,18 @@ public:
             std::make_shared<SkPathBuilder>(std::move(builder))) {}
 
   size_t getMemoryPressure() override {
-    auto builder = getObject();
-    if (!builder)
+    if (isDisposed()) {
       return 0;
-    // Estimate memory usage based on snapshot
-    return builder->snapshot().approximateBytesUsed();
+    }
+    auto builder = getObjectUnchecked();
+    if (!builder) {
+      return 0;
+    }
+    // The point, verb and conic weight arrays of the builder. Snapshotting
+    // the path to measure it would copy them, and this runs on every round
+    // trip of the object to JS.
+    return builder->points().size_bytes() + builder->verbs().size_bytes() +
+           builder->conicWeights().size_bytes();
   }
 
   static jsi::Value toValue(jsi::Runtime &runtime,

package/cpp/api/JsiSkPictureRecorder.h

@@ -58,7 +58,8 @@ public:
                   &JsiSkPictureRecorder::finishRecordingAsPicture);
   }
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  // The recorded picture reports its own size once finished.
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {

package/cpp/api/JsiSkShader.h

@@ -29,7 +29,9 @@ public:
       : JsiSkWrappingSkPtrNativeObject<JsiSkShader, SkShader>(
             std::move(context), std::move(shader)) {}
 
-  size_t getMemoryPressure() override { return 1024 * 1024; }
+  // A shader node is a few hundred bytes; the images it may reference
+  // are reported by their own wrappers.
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   static sk_sp<SkShader> fromValue(jsi::Runtime &runtime,
                                    const jsi::Value &obj) {

package/cpp/api/JsiSkSkottie.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <optional>
 #include <string>
@@ -31,9 +32,9 @@
 #pragma clang diagnostic pop
 
 namespace RNSkia {
-using namespace facebook;
+namespace jsi = facebook::jsi;
 
-std::unique_ptr<SkCodec> DecodeImageData(sk_sp<SkData> data) {
+inline std::unique_ptr<SkCodec> DecodeImageData(sk_sp<SkData> data) {
   if (data == nullptr) {
     return nullptr;
   }
@@ -74,6 +75,8 @@ public:
       if (!codec) {
         return nullptr;
       }
+      // The asset keeps its decoded frame for the lifetime of the animation.
+      _decodedImageBytes += codec->getInfo().computeMinByteSize();
       return skresources::MultiFrameImageAsset::Make(std::move(codec));
     }
 
@@ -102,11 +105,16 @@ public:
     return this->findAsset(name);
   }
 
+  // Bytes of the decoded images for the assets loaded so far.
+  size_t decodedImageBytes() const { return _decodedImageBytes; }
+
 private:
   explicit SkottieAssetProvider(AssetMap assets, sk_sp<SkFontMgr> fontMgr)
       : fAssets(std::move(assets)), fFontMgr(std::move(fontMgr)) {}
   const AssetMap fAssets;
   const sk_sp<SkFontMgr> fFontMgr;
+  // loadImageAsset() is const in skottie::ResourceProvider.
+  mutable size_t _decodedImageBytes = 0;
 
   sk_sp<SkData> findAsset(const char name[]) const {
     auto it = fAssets.find(name);
@@ -121,6 +129,12 @@ class ManagedAnimation {
 public:
   ManagedAnimation(std::string json, SkottieAssetProvider::AssetMap assets,
                    sk_sp<SkFontMgr> fontMgr) {
+    _approximateBytesUsed = json.size();
+    for (const auto &asset : assets) {
+      if (asset.second) {
+        _approximateBytesUsed += asset.second->size();
+      }
+    }
     _propManager = std::make_unique<CustomPropertyManager>(
         CustomPropertyManager::Mode::kCollapseProperties, "");
     _resourceProvider =
@@ -132,6 +146,8 @@ public:
     builder->setPropertyObserver(_propManager->getPropertyObserver());
     _animation = builder->make(json.c_str(), json.size());
     _slotManager = builder->getSlotManager();
+    // Image assets are loaded while the animation is built.
+    _approximateBytesUsed += _resourceProvider->decodedImageBytes();
   }
 
   ~ManagedAnimation() {
@@ -151,6 +167,10 @@ public:
   sk_sp<skottie::SlotManager> _slotManager = nullptr;
   sk_sp<SkottieAssetProvider> _resourceProvider = nullptr;
   std::unique_ptr<CustomPropertyManager> _propManager = nullptr;
+  // Size of the animation JSON, its encoded assets and its decoded images:
+  // the memory the animation actually owns (the scene graph is in the same
+  // order as the JSON). Used as the GC hint for the wrapper.
+  size_t _approximateBytesUsed = 0;
 };
 
 class JsiSkSkottie
@@ -322,8 +342,7 @@ public:
     if (!slotID.has_value() || !scalar.has_value()) {
       return false;
     }
-    return getObject()->_slotManager->setScalarSlot(SkString(*slotID),
-                                                    *scalar);
+    return getObject()->_slotManager->setScalarSlot(SkString(*slotID), *scalar);
   }
 
   bool setVec2Slot(JsiOptional<std::string> slotID,
@@ -579,31 +598,13 @@ public:
 
   size_t getMemoryPressure() override {
     auto animation = getObject();
-    if (!animation || !animation->_animation) {
-      return 1024; // Base size if no animation
+    if (!animation) {
+      return kMinMemoryPressure;
     }
-
-    auto size = animation->_animation->size();
-    auto duration = animation->_animation->duration();
-    auto fps = animation->_animation->fps();
-
-    // Estimate memory usage based on animation properties
-    // Base calculation: width * height * 4 bytes per pixel * estimated frame
-    // count
-    size_t frameCount = static_cast<size_t>(duration * fps);
-    size_t estimatedFrameSize =
-        static_cast<size_t>(size.width() * size.height() * 4);
-
-    // Conservative estimate: assume some frames are cached
-    size_t cachedFrames =
-        std::min(frameCount, static_cast<size_t>(60)); // Max 60 cached frames
-    size_t animationMemory = estimatedFrameSize * cachedFrames;
-
-    // Add base overhead for animation data structures
-    size_t baseOverhead =
-        64 * 1024; // 64KB for metadata, property managers, etc.
-
-    return animationMemory + baseOverhead;
+    // Skottie keeps no frame cache: report the bytes the animation owns.
+    // Estimating a pixel cache here (width * height * 4 * 60 frames) charged
+    // hundreds of MB per wrapper, and each capture in a worklet repeated it.
+    return std::max(animation->_approximateBytesUsed, kMinMemoryPressure);
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkStrutStyle.h

@@ -20,7 +20,7 @@ namespace jsi = facebook::jsi;
 
 namespace para = skia::textlayout;
 
-bool asBool(jsi::Runtime &runtime, const jsi::Value &value) {
+inline bool asBool(jsi::Runtime &runtime, const jsi::Value &value) {
   if (!value.isBool()) {
     throw jsi::JSError(runtime, "Expected boolean value");
   }