@shopify/react-native-skia 2.9.1-next.1 → 2.10.0

package/cpp/api/recorder/DataTypes.h

@@ -51,12 +51,9 @@ std::shared_ptr<SkRect> processRect(jsi::Runtime &runtime,
                                     const jsi::Value &value) {
   if (value.isObject()) {
     auto object = value.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      auto ptr = std::dynamic_pointer_cast<JsiSkRect>(
-          value.asObject(runtime).asHostObject(runtime));
-      if (ptr != nullptr) {
-        return ptr->getObject();
-      }
+    auto ptr = tryGetJsiObject<JsiSkRect>(runtime, object);
+    if (ptr != nullptr) {
+      return ptr->getObject();
     } else if (object.hasProperty(runtime, "x") &&
                object.hasProperty(runtime, "y") &&
                object.hasProperty(runtime, "width") &&
@@ -88,12 +85,9 @@ std::shared_ptr<SkRRect> processRRect(jsi::Runtime &runtime,
                                       const jsi::Value &value) {
   if (value.isObject()) {
     auto object = value.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      auto ptr = std::dynamic_pointer_cast<JsiSkRRect>(
-          value.asObject(runtime).asHostObject(runtime));
-      if (ptr != nullptr) {
-        return ptr->getObject();
-      }
+    auto ptr = tryGetJsiObject<JsiSkRRect>(runtime, object);
+    if (ptr != nullptr) {
+      return ptr->getObject();
     } else if (object.hasProperty(runtime, "rect") &&
                object.hasProperty(runtime, "rx") &&
                object.hasProperty(runtime, "ry")) {
@@ -136,10 +130,8 @@ std::shared_ptr<SkPath> processPath(jsi::Runtime &runtime,
     } else {
       throw std::runtime_error("Could not parse path from string.");
     }
-  } else if (value.isObject() &&
-             value.asObject(runtime).isHostObject(runtime)) {
-    auto ptr = std::dynamic_pointer_cast<JsiSkPath>(
-        value.asObject(runtime).asHostObject(runtime));
+  } else {
+    auto ptr = tryGetJsiObject<JsiSkPath>(runtime, value);
     if (ptr != nullptr) {
       return std::make_shared<SkPath>(ptr->getObject()->snapshot());
     }

package/cpp/api/recorder/JsiRecorder.h

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "api/JsiSkCanvas.h"
-#include "api/JsiSkHostObjects.h"
+#include "api/JsiSkNativeObjects.h"
 #include "api/JsiSkPicture.h"
 
 #include "DrawingCtx.h"
@@ -19,11 +19,14 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiRecorder : public JsiSkWrappingSharedPtrHostObject<Recorder> {
+class JsiRecorder
+    : public JsiSkWrappingSharedPtrNativeObject<JsiRecorder, Recorder> {
 public:
+  static constexpr const char *CLASS_NAME = "Recorder";
+
   JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkWrappingSharedPtrHostObject(std::move(context),
-                                         std::make_shared<Recorder>()) {
+      : JsiSkWrappingSharedPtrNativeObject<JsiRecorder, Recorder>(
+            std::move(context), std::make_shared<Recorder>()) {
     getObject()->_context = getContext();
   }
 
@@ -61,7 +64,8 @@ public:
 
     // Get the JsiSkPicture from the argument
     auto pictureObject = arguments[0].asObject(runtime);
-    auto pictureHostObject = pictureObject.asHostObject<JsiSkPicture>(runtime);
+    auto pictureHostObject =
+        tryGetJsiObject<JsiSkPicture>(runtime, pictureObject);
     if (!pictureHostObject) {
       throw jsi::JSError(runtime, "Invalid Picture object provided to play()");
     }
@@ -302,65 +306,89 @@ public:
     return jsi::Value::undefined();
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiRecorder, Recorder)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiRecorder, saveGroup),
-                       JSI_EXPORT_FUNC(JsiRecorder, restoreGroup),
-                       JSI_EXPORT_FUNC(JsiRecorder, savePaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, restorePaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, restorePaintDeclaration),
-                       JSI_EXPORT_FUNC(JsiRecorder, materializePaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushPathEffect),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushImageFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushColorFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushShader),
-                       JSI_EXPORT_FUNC(JsiRecorder, pushBlurMaskFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, composePathEffect),
-                       JSI_EXPORT_FUNC(JsiRecorder, composeColorFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, composeImageFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, saveCTM),
-                       JSI_EXPORT_FUNC(JsiRecorder, restoreCTM),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPaint),
-                       JSI_EXPORT_FUNC(JsiRecorder, saveLayer),
-                       JSI_EXPORT_FUNC(JsiRecorder, saveBackdropFilter),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawBox),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawImage),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawCircle),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPoints),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPath),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawRect),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawRRect),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawOval),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawLine),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPatch),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawVertices),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawDiffRect),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawText),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawTextPath),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawTextBlob),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawGlyphs),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawPicture),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawImageSVG),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawParagraph),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawAtlas),
-                       JSI_EXPORT_FUNC(JsiRecorder, drawSkottie),
-                       JSI_EXPORT_FUNC(JsiRecorder, play),
-                       JSI_EXPORT_FUNC(JsiRecorder, applyUpdates),
-                       JSI_EXPORT_FUNC(JsiRecorder, reset))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "saveGroup", &JsiRecorder::saveGroup);
+    installHostMethod(runtime, prototype, "restoreGroup",
+                      &JsiRecorder::restoreGroup);
+    installHostMethod(runtime, prototype, "savePaint", &JsiRecorder::savePaint);
+    installHostMethod(runtime, prototype, "restorePaint",
+                      &JsiRecorder::restorePaint);
+    installHostMethod(runtime, prototype, "restorePaintDeclaration",
+                      &JsiRecorder::restorePaintDeclaration);
+    installHostMethod(runtime, prototype, "materializePaint",
+                      &JsiRecorder::materializePaint);
+    installHostMethod(runtime, prototype, "pushPathEffect",
+                      &JsiRecorder::pushPathEffect);
+    installHostMethod(runtime, prototype, "pushImageFilter",
+                      &JsiRecorder::pushImageFilter);
+    installHostMethod(runtime, prototype, "pushColorFilter",
+                      &JsiRecorder::pushColorFilter);
+    installHostMethod(runtime, prototype, "pushShader",
+                      &JsiRecorder::pushShader);
+    installHostMethod(runtime, prototype, "pushBlurMaskFilter",
+                      &JsiRecorder::pushBlurMaskFilter);
+    installHostMethod(runtime, prototype, "composePathEffect",
+                      &JsiRecorder::composePathEffect);
+    installHostMethod(runtime, prototype, "composeColorFilter",
+                      &JsiRecorder::composeColorFilter);
+    installHostMethod(runtime, prototype, "composeImageFilter",
+                      &JsiRecorder::composeImageFilter);
+    installHostMethod(runtime, prototype, "saveCTM", &JsiRecorder::saveCTM);
+    installHostMethod(runtime, prototype, "restoreCTM",
+                      &JsiRecorder::restoreCTM);
+    installHostMethod(runtime, prototype, "drawPaint", &JsiRecorder::drawPaint);
+    installHostMethod(runtime, prototype, "saveLayer", &JsiRecorder::saveLayer);
+    installHostMethod(runtime, prototype, "saveBackdropFilter",
+                      &JsiRecorder::saveBackdropFilter);
+    installHostMethod(runtime, prototype, "drawBox", &JsiRecorder::drawBox);
+    installHostMethod(runtime, prototype, "drawImage", &JsiRecorder::drawImage);
+    installHostMethod(runtime, prototype, "drawCircle",
+                      &JsiRecorder::drawCircle);
+    installHostMethod(runtime, prototype, "drawPoints",
+                      &JsiRecorder::drawPoints);
+    installHostMethod(runtime, prototype, "drawPath", &JsiRecorder::drawPath);
+    installHostMethod(runtime, prototype, "drawRect", &JsiRecorder::drawRect);
+    installHostMethod(runtime, prototype, "drawRRect", &JsiRecorder::drawRRect);
+    installHostMethod(runtime, prototype, "drawOval", &JsiRecorder::drawOval);
+    installHostMethod(runtime, prototype, "drawLine", &JsiRecorder::drawLine);
+    installHostMethod(runtime, prototype, "drawPatch", &JsiRecorder::drawPatch);
+    installHostMethod(runtime, prototype, "drawVertices",
+                      &JsiRecorder::drawVertices);
+    installHostMethod(runtime, prototype, "drawDiffRect",
+                      &JsiRecorder::drawDiffRect);
+    installHostMethod(runtime, prototype, "drawText", &JsiRecorder::drawText);
+    installHostMethod(runtime, prototype, "drawTextPath",
+                      &JsiRecorder::drawTextPath);
+    installHostMethod(runtime, prototype, "drawTextBlob",
+                      &JsiRecorder::drawTextBlob);
+    installHostMethod(runtime, prototype, "drawGlyphs",
+                      &JsiRecorder::drawGlyphs);
+    installHostMethod(runtime, prototype, "drawPicture",
+                      &JsiRecorder::drawPicture);
+    installHostMethod(runtime, prototype, "drawImageSVG",
+                      &JsiRecorder::drawImageSVG);
+    installHostMethod(runtime, prototype, "drawParagraph",
+                      &JsiRecorder::drawParagraph);
+    installHostMethod(runtime, prototype, "drawAtlas", &JsiRecorder::drawAtlas);
+    installHostMethod(runtime, prototype, "drawSkottie",
+                      &JsiRecorder::drawSkottie);
+    installHostMethod(runtime, prototype, "play", &JsiRecorder::play);
+    installHostMethod(runtime, prototype, "applyUpdates",
+                      &JsiRecorder::applyUpdates);
+    installHostMethod(runtime, prototype, "reset", &JsiRecorder::reset);
+  }
 
   // This has no basis in reality but since since these are private long-lived
   // objects, we think it is more than fine.
-  size_t getMemoryPressure() const override { return 5 * 1024 * 1024; }
-
-  std::string getObjectType() const override { return "JsiRecorder"; }
+  size_t getMemoryPressure() override { return 5 * 1024 * 1024; }
 
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {
     return JSI_HOST_FUNCTION_LAMBDA {
       // Return the newly constructed object
       auto recorder = std::make_shared<JsiRecorder>(std::move(context));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, recorder,
-                                                         context);
+      return makeJsiObject(runtime, std::move(recorder));
     };
   }
 };

package/cpp/api/recorder/RNRecorder.h

@@ -17,8 +17,8 @@
 #include "ImageFilters.h"
 #include "Paint.h"
 #include "PathEffects.h"
-#include "rnskia/RNSkPlatformContext.h"
 #include "Shaders.h"
+#include "rnskia/RNSkPlatformContext.h"
 
 namespace RNSkia {
 

package/cpp/jsi/BoxedNativeObject.h

@@ -0,0 +1,146 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+namespace RNJsi {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Registry mapping a NativeObject class brand (CLASS_NAME) to a reconstructor
+ * that can recreate a fully functional JS object (prototype + native state)
+ * on any runtime. This is what enables native objects (Skia and WebGPU) to
+ * travel between the React Native runtime and secondary runtimes (Reanimated
+ * worklets) via BoxedNativeObject.
+ */
+class BoxedNativeObjectRegistry {
+public:
+  using Reconstructor = std::function<jsi::Value(
+      jsi::Runtime &, std::shared_ptr<jsi::NativeState>)>;
+
+  static BoxedNativeObjectRegistry &getInstance() {
+    static BoxedNativeObjectRegistry instance;
+    return instance;
+  }
+
+  void registerClass(const std::string &brand, Reconstructor reconstructor) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    // Brands are the unboxing key and must be unique process-wide; a silent
+    // overwrite would make one class unbox into another's reconstructor.
+    if (_reconstructors.count(brand) > 0) {
+      throw std::runtime_error("Duplicate native object brand registered: " +
+                               brand);
+    }
+    _reconstructors[brand] = std::move(reconstructor);
+  }
+
+  jsi::Value reconstruct(jsi::Runtime &runtime, const std::string &brand,
+                         std::shared_ptr<jsi::NativeState> state) {
+    Reconstructor reconstructor;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      auto it = _reconstructors.find(brand);
+      if (it == _reconstructors.end()) {
+        throw jsi::JSError(runtime,
+                           "No native class registered for brand: " + brand);
+      }
+      reconstructor = it->second;
+    }
+    return reconstructor(runtime, std::move(state));
+  }
+
+private:
+  BoxedNativeObjectRegistry() = default;
+  std::mutex _mutex;
+  std::unordered_map<std::string, Reconstructor> _reconstructors;
+};
+
+/**
+ * HostObject bridge used to move NativeObjects between runtimes.
+ *
+ * NativeObject-based values are plain JS objects carrying jsi::NativeState;
+ * worklets cannot serialize their prototype, so they are "boxed" into this
+ * HostObject (which worklets pass across runtimes by reference) and unboxed
+ * on the target runtime, where the prototype is re-installed from the class
+ * registry. See registerCustomSerializable in
+ * src/skia/SkiaWorkletSerialization.ts.
+ */
+class BoxedNativeObject : public jsi::HostObject {
+public:
+  BoxedNativeObject(std::shared_ptr<jsi::NativeState> state, std::string brand)
+      : _state(std::move(state)), _brand(std::move(brand)) {}
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
+    auto propName = name.utf8(runtime);
+    if (propName == "unbox") {
+      auto state = _state;
+      auto brand = _brand;
+      return jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forUtf8(runtime, "unbox"), 0,
+          [state, brand](jsi::Runtime &rt, const jsi::Value &,
+                         const jsi::Value *, size_t) -> jsi::Value {
+            return BoxedNativeObjectRegistry::getInstance().reconstruct(
+                rt, brand, state);
+          });
+    }
+    if (propName == "__boxedNativeObject") {
+      return jsi::Value(true);
+    }
+    if (propName == "__brand") {
+      return jsi::String::createFromUtf8(runtime, _brand);
+    }
+    return jsi::Value::undefined();
+  }
+
+  void set(jsi::Runtime &runtime, const jsi::PropNameID &,
+           const jsi::Value &) override {
+    throw jsi::JSError(runtime, "Boxed native objects are read-only");
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override {
+    std::vector<jsi::PropNameID> names;
+    names.reserve(3);
+    names.push_back(jsi::PropNameID::forUtf8(rt, "unbox"));
+    names.push_back(jsi::PropNameID::forUtf8(rt, "__boxedNativeObject"));
+    names.push_back(jsi::PropNameID::forUtf8(rt, "__brand"));
+    return names;
+  }
+
+private:
+  std::shared_ptr<jsi::NativeState> _state;
+  std::string _brand;
+};
+
+/**
+ * Boxes a NativeObject-backed JS value so it can be serialized by worklets
+ * and unboxed on another runtime.
+ */
+inline jsi::Value boxNativeObject(jsi::Runtime &runtime,
+                                  const jsi::Value &value) {
+  if (!value.isObject()) {
+    throw jsi::JSError(runtime, "box() expects a native object");
+  }
+  auto object = value.asObject(runtime);
+  if (!object.hasNativeState(runtime)) {
+    throw jsi::JSError(runtime, "box() expects a native object");
+  }
+  auto brand = object.getProperty(runtime, "__typename__");
+  if (!brand.isString()) {
+    throw jsi::JSError(runtime, "box() expects a native object");
+  }
+  return jsi::Object::createFromHostObject(
+      runtime, std::make_shared<BoxedNativeObject>(
+                   object.getNativeState(runtime),
+                   brand.asString(runtime).utf8(runtime)));
+}
+
+} // namespace RNJsi

package/cpp/{jsi2 → jsi}/EnumMapper.h

@@ -12,7 +12,10 @@ namespace EnumMapper {
 // outEnum)`
 // 2. `static void convertEnumToJSUnion(Enum inEnum, std::string* outUnion)`
 
-static std::runtime_error invalidUnion(const std::string &passedUnion) {
+// inline (not static): this header is now included by every TU via
+// NativeObject.h, and an unused file-scope static would trip
+// -Werror=unused-function in non-Graphite builds.
+inline std::runtime_error invalidUnion(const std::string &passedUnion) {
   return std::runtime_error(
       "Cannot convert JS Value to Enum: Invalid Union value passed! (\"" +
       std::string(passedUnion) + "\")");