@shopify/react-native-skia 2.12.0-next.1 → 2.13.0

package/apple/SkiaUIView.h

@@ -10,29 +10,14 @@
 #import <React/RCTUIKit.h>
 #endif // !TARGET_OS_OSX
 
+#import <React/RCTViewComponentView.h>
+
 #import "RNSkAppleView.h"
 #import "RNSkManager.h"
 #import "SkiaManager.h"
 
-#if RCT_NEW_ARCH_ENABLED
-#import <React/RCTViewComponentView.h>
-#endif // RCT_NEW_ARCH_ENABLED
-
-@interface SkiaUIView :
-#if RCT_NEW_ARCH_ENABLED
-    RCTViewComponentView
-#else
-#if !TARGET_OS_OSX
-    UIView
-#else
-    RCTUIView
-#endif // !TARGET_OS_OSX
-#endif // RCT_NEW_ARCH_ENABLED
+@interface SkiaUIView : RCTViewComponentView
 
-- (instancetype)
-    initWithManager:(RNSkia::RNSkManager *)manager
-            factory:(std::function<std::shared_ptr<RNSkBaseAppleView>(
-                         std::shared_ptr<RNSkia::RNSkPlatformContext>)>)factory;
 - (void)initCommon:(RNSkia::RNSkManager *)manager
            factory:(std::function<std::shared_ptr<RNSkBaseAppleView>(
                         std::shared_ptr<RNSkia::RNSkPlatformContext>)>)factory;

package/apple/SkiaUIView.mm

@@ -1,5 +1,4 @@
 #import <QuartzCore/CATransaction.h>
-#import <React/RCTBridge.h>
 
 #import "RNSkiaModule.h"
 #import "SkiaUIView.h"
@@ -24,24 +23,6 @@
 
 #pragma mark Initialization and destruction
 
-- (instancetype)initWithManager:(RNSkia::RNSkManager *)manager
-                        factory:
-                            (std::function<std::shared_ptr<RNSkBaseAppleView>(
-                                 std::shared_ptr<RNSkia::RNSkPlatformContext>)>)
-                                factory {
-  self = [super init];
-  if (self) {
-    [self initCommon:manager factory:factory];
-  }
-  // Listen to notifications about module invalidation
-  [[NSNotificationCenter defaultCenter]
-      addObserver:self
-         selector:@selector(willInvalidateModules)
-             name:RCTBridgeWillInvalidateModulesNotification
-           object:nil];
-  return self;
-}
-
 - (void)initCommon:(RNSkia::RNSkManager *)manager
            factory:(std::function<std::shared_ptr<RNSkBaseAppleView>(
                         std::shared_ptr<RNSkia::RNSkPlatformContext>)>)factory {
@@ -51,11 +32,6 @@
   _factory = factory;
 }
 
-- (void)willInvalidateModules {
-  _impl = nullptr;
-  _manager = nullptr;
-}
-
 #pragma mark Lifecycle
 
 #if !TARGET_OS_OSX
@@ -99,13 +75,8 @@
 
 - (void)dealloc {
   [self unregisterView];
-  [[NSNotificationCenter defaultCenter]
-      removeObserver:self
-                name:RCTBridgeWillInvalidateModulesNotification
-              object:nil];
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
 - (void)prepareForRecycle {
   [super prepareForRecycle];
   [self unregisterView];
@@ -120,7 +91,6 @@
     _manager = [SkiaManager latestActiveSkManager].get();
   }
 }
-#endif // RCT_NEW_ARCH_ENABLED
 
 - (void)unregisterView {
   if (_manager != nullptr && _nativeId != 0) {

package/cpp/api/CustomBlendModes.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <stdexcept>
+#include <string>
+
 #include "include/core/SkBlender.h"
 #include "include/core/SkPaint.h"
 #include "include/core/SkString.h"
@@ -94,4 +97,18 @@ inline void applyBlendMode(SkPaint &paint, int blendModeValue) {
   }
 }
 
+// Converts a JS blend mode value to an SkBlendMode for the Skia entry points
+// that take a plain SkBlendMode rather than a paint (drawPatch, drawVertices,
+// drawAtlas, drawColor). The custom blend modes above are implemented as
+// blenders on an SkPaint and have no SkBlendMode equivalent, so they - and any
+// other out of range value - are rejected instead of being cast blindly.
+inline SkBlendMode toBlendMode(double blendModeValue) {
+  auto value = static_cast<int>(blendModeValue);
+  if (value < 0 || value > static_cast<int>(SkBlendMode::kLastMode)) {
+    throw std::invalid_argument("Unsupported blend mode: " +
+                                std::to_string(value));
+  }
+  return static_cast<SkBlendMode>(value);
+}
+
 } // namespace RNSkia

package/cpp/api/JsiSkApi.h

@@ -56,7 +56,6 @@
 #include "JsiSkTypefaceFactory.h"
 #include "JsiSkTypefaceFontProviderFactory.h"
 #include "JsiSkVertices.h"
-#include "JsiSkiaContext.h"
 #include "JsiSkottieFactory.h"
 #include "JsiVideo.h"
 #include "api/recorder/JsiRecorder.h"
@@ -116,10 +115,6 @@ public:
     return JsiVideo::createCtor(getContext())(runtime, thisValue, arguments,
                                               count);
   }
-  JSI_HOST_FUNCTION(Context) {
-    return JsiSkiaContext::createCtor(getContext())(runtime, thisValue,
-                                                    arguments, count);
-  }
   JSI_HOST_FUNCTION(Font) {
     return JsiSkFont::createCtor(getContext())(runtime, thisValue, arguments,
                                                count);
@@ -256,7 +251,6 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installHostMethod(runtime, prototype, "Video", &JsiSkApi::Video);
-    installHostMethod(runtime, prototype, "Context", &JsiSkApi::Context);
     installHostMethod(runtime, prototype, "getNativeDevice",
                       &JsiSkApi::getNativeDevice);
     installHostMethod(runtime, prototype, "Font", &JsiSkApi::Font);

package/cpp/api/JsiSkCanvas.h

@@ -5,6 +5,7 @@
 #include <utility>
 #include <vector>
 
+#include "CustomBlendModes.h"
 #include "JsiSkConverters.h"
 #include "JsiSkFont.h"
 #include "JsiSkImage.h"
@@ -226,8 +227,7 @@ public:
 
   void drawVertices(sk_sp<SkVertices> vertices, double blendMode,
                     std::shared_ptr<SkPaint> paint) {
-    _canvas->drawVertices(vertices, static_cast<SkBlendMode>(blendMode),
-                          *paint);
+    _canvas->drawVertices(vertices, toBlendMode(blendMode), *paint);
   }
 
   JSI_HOST_FUNCTION(drawPatch) {
@@ -287,11 +287,19 @@ public:
       }
     }
 
-    auto paint =
-        count >= 4 ? JsiSkPaint::fromValue(runtime, arguments[4]) : nullptr;
-    auto blendMode = static_cast<SkBlendMode>(arguments[3].asNumber());
+    auto blendMode =
+        count >= 4 && !arguments[3].isNull() && !arguments[3].isUndefined()
+            ? toBlendMode(arguments[3].asNumber())
+            : SkBlendMode::kModulate;
+
+    std::shared_ptr<SkPaint> paint;
+    if (count >= 5 && !arguments[4].isNull() && !arguments[4].isUndefined()) {
+      paint = JsiSkPaint::fromValue(runtime, arguments[4]);
+    }
+    SkPaint defaultPaint;
     _canvas->drawPatch(cubics.data(), colors.empty() ? nullptr : colors.data(),
-                       texs.empty() ? nullptr : texs.data(), blendMode, *paint);
+                       texs.empty() ? nullptr : texs.data(), blendMode,
+                       paint ? *paint : defaultPaint);
     return jsi::Value::undefined();
   }
 
@@ -392,7 +400,7 @@ public:
 
   void drawColor(JsiColor cl, JsiOptional<double> mode) {
     if (mode.has_value()) {
-      _canvas->drawColor(cl, static_cast<SkBlendMode>(*mode));
+      _canvas->drawColor(cl, toBlendMode(*mode));
     } else {
       _canvas->drawColor(cl);
     }
@@ -411,9 +419,10 @@ public:
     auto rects = arguments[1].asObject(runtime).asArray(runtime);
     auto transforms = arguments[2].asObject(runtime).asArray(runtime);
     auto paint = JsiSkPaint::fromValue(runtime, arguments[3]);
-    auto blendMode = count > 5 && !arguments[4].isUndefined()
-                         ? static_cast<SkBlendMode>(arguments[4].asNumber())
-                         : SkBlendMode::kDstOver;
+    auto blendMode =
+        count > 4 && !arguments[4].isNull() && !arguments[4].isUndefined()
+            ? toBlendMode(arguments[4].asNumber())
+            : SkBlendMode::kDstOver;
 
     std::vector<SkRSXform> xforms;
     int xformsSize = static_cast<int>(transforms.size(runtime));

package/cpp/api/JsiSkFont.h

@@ -135,8 +135,9 @@ public:
   bool isEmbolden() { return getObject()->isEmbolden(); }
 
   std::shared_ptr<JsiSkTypeface> getTypeface() {
-    return std::make_shared<JsiSkTypeface>(
-        getContext(), sk_sp<SkTypeface>(getObject()->getTypeface()));
+    // refTypeface(), not getTypeface(): the wrapper owns what it is handed.
+    return std::make_shared<JsiSkTypeface>(getContext(),
+                                           getObject()->refTypeface());
   }
 
   void setEdging(double edging) {
@@ -161,15 +162,9 @@ public:
 
   void setSize(double size) { getObject()->setSize(size); }
 
-  // The JS API declares booleans here, but the previous implementation read
-  // the arguments with asNumber() — keep accepting numbers.
-  void setEmbolden(double embolden) {
-    getObject()->setEmbolden(static_cast<bool>(embolden));
-  }
+  void setEmbolden(bool embolden) { getObject()->setEmbolden(embolden); }
 
-  void setSubpixel(double subpixel) {
-    getObject()->setSubpixel(static_cast<bool>(subpixel));
-  }
+  void setSubpixel(bool subpixel) { getObject()->setSubpixel(subpixel); }
 
   void setTypeface(std::variant<std::nullptr_t, sk_sp<SkTypeface>> typeface) {
     getObject()->setTypeface(

package/cpp/api/JsiSkMatrix.h

@@ -69,12 +69,14 @@ public:
 
   void postTranslate(double x, double y) { getObject()->postTranslate(x, y); }
 
+  // A missing y means a uniform scale, matching the CanvasKit backend and the
+  // SkMatrix type, where y is optional rather than defaulted to 1.
   void scale(double x, JsiOptional<double> y) {
-    getObject()->preScale(x, y.has_value() ? *y : 1);
+    getObject()->preScale(x, y.has_value() ? *y : x);
   }
 
   void postScale(double x, JsiOptional<double> y) {
-    getObject()->postScale(x, y.has_value() ? *y : 1);
+    getObject()->postScale(x, y.has_value() ? *y : x);
   }
 
   void skew(double x, double y) { getObject()->preSkew(x, y); }

package/cpp/api/JsiSkSVGFactory.h

@@ -116,6 +116,10 @@ private:
     builder.setResourceProvider(provider);
 
     auto svg_dom = builder.make(*stream);
+    if (!svg_dom) {
+      return jsi::Value::null();
+    }
+
     return makeJsiObject(
         runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
   }

package/cpp/api/recorder/Convertor.h

@@ -361,13 +361,16 @@ SkM44 getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
         m4.preScale(1, s);
       } else if (key == "skewX") {
         auto angle = value.getProperty(runtime, key.c_str()).asNumber();
-        SkM44 skewX(1, 0, 0, 0, std::tan(angle), 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+        // The SkM44 constructor takes its arguments in row-major reading
+        // order, so the shear factor of a horizontal skew belongs in row 0,
+        // where it scales y into x.
+        SkM44 skewX(1, std::tan(angle), 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
                     1);
         m4.preConcat(skewX);
 
       } else if (key == "skewY") {
         auto angle = value.getProperty(runtime, key.c_str()).asNumber();
-        SkM44 skewY(1, std::tan(angle), 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+        SkM44 skewY(1, 0, 0, 0, std::tan(angle), 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
                     1);
         m4.preConcat(skewY);
       } else if (key == "rotate" || key == "rotateZ") {

package/cpp/api/recorder/Drawings.h

@@ -149,6 +149,9 @@ public:
       if (hasStrokeOptions) {
         const auto &stroke = props.stroke.value();
         SkPaint strokePaint;
+        // A default SkPaint is fill-style, and FillPathWithPaint only
+        // outlines a paint that strokes.
+        strokePaint.setStyle(SkPaint::kStroke_Style);
 
         if (stroke.cap.has_value()) {
           strokePaint.setStrokeCap(stroke.cap.value());
@@ -166,11 +169,18 @@ public:
           strokePaint.setStrokeMiter(stroke.miter_limit.value());
         }
 
+        float precision = stroke.precision.value_or(1.0f);
+
         SkPathBuilder resultBuilder;
-        if (!skpathutils::FillPathWithPaint(*p, strokePaint, &resultBuilder)) {
-          throw std::runtime_error("Failed to apply stroke to path");
+        auto ctm = SkMatrix::Scale(precision, precision);
+        if (skpathutils::FillPathWithPaint(*p, strokePaint, &resultBuilder,
+                                           nullptr, ctm)) {
+          pathToUse = std::make_shared<const SkPath>(resultBuilder.snapshot());
+        } else {
+          // The JS player keeps the unstroked path when Path.Stroke returns
+          // null (e.g. a hairline width of 0).
+          pathToUse = std::const_pointer_cast<const SkPath>(p);
         }
-        pathToUse = std::make_shared<const SkPath>(resultBuilder.snapshot());
       } else {
         pathToUse = std::const_pointer_cast<const SkPath>(p);
       }

package/cpp/api/recorder/ImageFilters.h

@@ -135,8 +135,22 @@ private:
     auto sourceAlpha = SkImageFilters::ColorFilter(
         SkColorFilters::Blend(SK_ColorBLACK, SkBlendMode::kSrcIn), nullptr);
 
+    // The shadow is generated outside the shape and then clipped back into it,
+    // so "outside" has to be the complement of the shape's silhouette. Taking
+    // SrcOut against the source graphic itself makes it the complement of the
+    // source's *alpha*: inside a translucent shape 1 - alpha is non-zero, so
+    // the shadow is generated across the whole interior and tints it, no matter
+    // how small the blur and the offset are (issue #2990). Saturating alpha
+    // first keeps the shadow tied to the shape's outline instead of to its
+    // opacity. 255 is the saturation point of an 8-bit alpha channel, so one
+    // unit of coverage is enough to reach 1.
+    static constexpr float kAlphaSaturate[20] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0};
+    auto coverage = SkImageFilters::ColorFilter(
+        SkColorFilters::Matrix(kAlphaSaturate), nullptr);
+
     auto f1 = SkImageFilters::ColorFilter(
-        SkColorFilters::Blend(color, SkBlendMode::kSrcOut), nullptr);
+        SkColorFilters::Blend(color, SkBlendMode::kSrcOut), coverage);
 
     auto f2 = SkImageFilters::Offset(dx, dy, f1);
     auto f3 = SkImageFilters::Blur(sigmaX, sigmaY, SkTileMode::kDecal, f2);

package/cpp/api/recorder/Paint.h

@@ -154,8 +154,15 @@ public:
     }
     ctx->savePaint();
     if (standalone) {
+      // Reset the paint that savePaint() just pushed instead of pushing a
+      // second one: the matching RestorePaintDeclaration pops a single frame,
+      // so an extra push would leave the enclosing group's opacity on the
+      // stack and leak it onto every sibling drawn afterwards. The fresh
+      // paint is anti-aliased to match the TS player, which resets with
+      // Skia.Paint().
       SkPaint freshPaint;
-      ctx->pushPaint(freshPaint);
+      freshPaint.setAntiAlias(true);
+      ctx->getPaint() = freshPaint;
     }
     auto &paint = ctx->getPaint();
     if (props.opacity.has_value()) {

package/cpp/jsi/JSICache.cpp

@@ -0,0 +1,99 @@
+#include "JSICache.h"
+
+#include <iterator>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace RNJsi {
+
+namespace {
+// Hidden global holding the per-runtime cache object. Named so it is
+// obviously ours if it ever shows up in a debugger or heap snapshot.
+constexpr const char *kGlobalName = "__rnskiaJsiCache";
+} // namespace
+
+std::mutex JSICache::_registryMutex;
+std::unordered_map<jsi::Runtime *, std::weak_ptr<JSICache>> JSICache::_registry;
+
+JSICache &JSICache::get(jsi::Runtime &runtime) {
+  {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    auto it = _registry.find(&runtime);
+    if (it != _registry.end()) {
+      if (auto cache = it->second.lock()) {
+        // The cache is kept alive by `runtime`'s global, so the raw
+        // reference stays valid for as long as the caller may legally use
+        // `runtime` on this thread.
+        return *cache;
+      }
+      // Expired: the runtime that owned this entry is gone and `&runtime` is
+      // a new runtime reusing the address. Fall through and recreate.
+    }
+  }
+  auto cache = getOrCreateOnGlobal(runtime);
+  {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    // Drop entries of runtimes that are gone so the map does not grow by one
+    // stale pointer per reload / worklet runtime.
+    for (auto it = _registry.begin(); it != _registry.end();) {
+      it = it->second.expired() ? _registry.erase(it) : std::next(it);
+    }
+    _registry[&runtime] = cache;
+  }
+  return *cache;
+}
+
+std::shared_ptr<JSICache> JSICache::getOrCreateOnGlobal(jsi::Runtime &runtime) {
+  auto global = runtime.global();
+  auto existing = global.getProperty(runtime, kGlobalName);
+  if (existing.isObject()) {
+    auto obj = existing.getObject(runtime);
+    if (obj.hasNativeState<JSICache>(runtime)) {
+      return obj.getNativeState<JSICache>(runtime);
+    }
+  }
+  if (!existing.isUndefined()) {
+    // Something else already claimed our global. The most likely cause is two
+    // copies of react-native-skia loaded in one process (each has its own
+    // JSICache type, so the NativeState check above fails). Say so instead of
+    // letting Object.defineProperty throw a bare TypeError on the
+    // non-configurable property.
+    throw std::runtime_error(
+        std::string("react-native-skia: global.") + kGlobalName +
+        " already exists but is not our JSICache. Is react-native-skia "
+        "linked twice, or is another module using this global?");
+  }
+  auto cache = std::make_shared<JSICache>();
+  jsi::Object holder(runtime);
+  holder.setNativeState(runtime, cache);
+  // Non-enumerable, non-writable, non-configurable: JS code must not be able
+  // to drop the holder (which would finalize the cache under our feet).
+  auto objectCtor = global.getPropertyAsObject(runtime, "Object");
+  auto defineProperty =
+      objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+  jsi::Object descriptor(runtime);
+  descriptor.setProperty(runtime, "value", std::move(holder));
+  descriptor.setProperty(runtime, "writable", false);
+  descriptor.setProperty(runtime, "enumerable", false);
+  descriptor.setProperty(runtime, "configurable", false);
+  defineProperty.call(runtime, global,
+                      jsi::String::createFromAscii(runtime, kGlobalName),
+                      descriptor);
+  return cache;
+}
+
+jsi::Object *JSICache::getPrototype(PrototypeKey key) {
+  auto it = _prototypes.find(key);
+  return it == _prototypes.end() ? nullptr : &it->second;
+}
+
+jsi::Object &JSICache::setPrototype(PrototypeKey key, jsi::Object prototype) {
+  auto [it, inserted] = _prototypes.insert_or_assign(key, std::move(prototype));
+  (void)inserted;
+  return it->second;
+}
+
+} // namespace RNJsi

package/cpp/jsi/JSICache.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <mutex>
+#include <typeindex>
+#include <unordered_map>
+
+namespace RNJsi {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Per-runtime store for JSI values that native code wants to keep across
+ * calls (currently: the prototype object of every NativeObject class).
+ *
+ * Ownership model (borrowed from react-native-nitro-modules' JSICache):
+ *
+ * - One JSICache exists per jsi::Runtime. It is attached as the NativeState
+ *   of a hidden object stored on that runtime's `global`, so the RUNTIME owns
+ *   the cache. When the runtime is destroyed the engine finalizes the object,
+ *   ~JSICache runs while the runtime is still alive, and every cached
+ *   jsi::Object is released correctly. Nothing outlives its runtime and
+ *   nothing has to be leaked.
+ *
+ * - Native code reaches the cache through JSICache::get(runtime). A static
+ *   map of std::weak_ptr, keyed by jsi::Runtime*, makes the lookup cheap; the
+ *   pointer is only a map key, never proof that a runtime is alive. If the
+ *   weak_ptr is expired (the runtime that owned it is gone) the entry is
+ *   recreated on the runtime asking for it. This is what makes an in-process
+ *   runtime recreate (expo-updates OTA apply, DevSettings.reload) safe even
+ *   when the new runtime is allocated at the address of the freed one: the
+ *   old cache was destroyed with the old runtime, so the reused address can
+ *   only ever resolve to a fresh cache.
+ *
+ * - The cache itself is not locked: a jsi::Runtime is single-threaded, and
+ *   the cache is only ever touched from its runtime's thread. Only the static
+ *   runtime -> cache map is guarded.
+ *
+ * The same mechanism works for worklet runtimes (Reanimated UI runtime,
+ * createWorkletRuntime, ...); each gets its own JSICache.
+ */
+class JSICache final : public jsi::NativeState {
+public:
+  /**
+   * Key identifying one cached prototype: the C++ type of the NativeObject
+   * subclass (std::type_index(typeid(Derived))), as in Nitro. It prints as
+   * the class name in a debugger.
+   */
+  using PrototypeKey = std::type_index;
+
+  /**
+   * Returns the cache owned by `runtime`, creating it on first use. Must be
+   * called on the runtime's thread.
+   */
+  static JSICache &get(jsi::Runtime &runtime);
+
+  /**
+   * Returns the cached prototype for `key` or nullptr if none was stored.
+   *
+   * The pointer points into `_prototypes`. std::unordered_map never
+   * invalidates pointers/references to elements on insert or rehash (only on
+   * erase of that element, which we never do), so it stays valid for as long
+   * as the runtime does. Do not swap the container for one without that
+   * guarantee (std::vector, absl::flat_hash_map, ...).
+   */
+  jsi::Object *getPrototype(PrototypeKey key);
+
+  /**
+   * Stores (or replaces) the prototype for `key` and returns it.
+   */
+  jsi::Object &setPrototype(PrototypeKey key, jsi::Object prototype);
+
+  JSICache() = default;
+  ~JSICache() override = default;
+  JSICache(const JSICache &) = delete;
+  JSICache &operator=(const JSICache &) = delete;
+
+private:
+  static std::shared_ptr<JSICache> getOrCreateOnGlobal(jsi::Runtime &runtime);
+
+  std::unordered_map<PrototypeKey, jsi::Object> _prototypes;
+
+  // Runtime -> cache. Weak on purpose: the runtime's global owns the cache.
+  static std::mutex _registryMutex;
+  static std::unordered_map<jsi::Runtime *, std::weak_ptr<JSICache>> _registry;
+};
+
+} // namespace RNJsi