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

package/src/sksg/Container.native.ts

@@ -1,6 +1,10 @@
 import Rea from "../external/reanimated/ReanimatedProxy";
 import type { Skia, SkPicture } from "../skia/types";
-import { HAS_REANIMATED_3 } from "../external/reanimated/renderHelpers";
+import {
+  HAS_REANIMATED_3,
+  HAS_REANIMATED_4,
+  REANIMATED_VERSION_MAJOR,
+} from "../external/reanimated/renderHelpers";
 import type { JsiRecorder } from "../skia/types/Recorder";
 
 import { ReanimatedRecorder } from "./Recorder/ReanimatedRecorder";
@@ -79,10 +83,44 @@ class NativeReanimatedContainer extends Container {
   }
 }
 
+let hasWarnedAboutReanimatedSupport = false;
+
+const reanimatedSupportError = () => {
+  if (REANIMATED_VERSION_MAJOR !== null && REANIMATED_VERSION_MAJOR >= 4) {
+    return (
+      "React Native Skia requires react-native-worklets >= 0.7.0 for its " +
+      "Reanimated integration on native platforms. Reanimated 4 is " +
+      "installed, but react-native-worklets is missing or too old. " +
+      "Please install or upgrade react-native-worklets."
+    );
+  }
+  return (
+    "React Native Skia requires Reanimated 4 (react-native-worklets >= " +
+    "0.7.0) for its Reanimated integration on native platforms. " +
+    "Reanimated 3 is not supported anymore: Skia objects cannot be used " +
+    "inside worklets or shared values with it. " +
+    "Please upgrade to react-native-reanimated >= 4.0.0."
+  );
+};
+
 export const createContainer = (Skia: Skia, nativeId: number) => {
-  if (HAS_REANIMATED_3 && nativeId !== -1) {
+  if (HAS_REANIMATED_4 && nativeId !== -1) {
     return new NativeReanimatedContainer(Skia, nativeId);
   } else {
+    if (HAS_REANIMATED_3 && !HAS_REANIMATED_4) {
+      const message = reanimatedSupportError();
+      if (__DEV__) {
+        // Fail loudly in development — a silent fallback to static rendering
+        // would only be noticed as frozen animations.
+        throw new Error(message);
+      }
+      if (!hasWarnedAboutReanimatedSupport) {
+        hasWarnedAboutReanimatedSupport = true;
+        console.error(
+          `${message} Falling back to static rendering (animations will not run).`
+        );
+      }
+    }
     return new StaticContainer(Skia, nativeId);
   }
 };

package/src/views/WebGPUCanvas.tsx

@@ -1,4 +1,4 @@
-import React, { useImperativeHandle, useRef, useState } from "react";
+import React, { useEffect, useImperativeHandle, useRef, useState } from "react";
 import type { ViewProps } from "react-native";
 import { View, Platform } from "react-native";
 
@@ -19,6 +19,9 @@ declare global {
       width: number,
       height: number
     ) => RNCanvasContext;
+    // Retires a canvas context; called by the Canvas on unmount (the Canvas
+    // owns the native registry entry for its contextId).
+    destroyContext: (contextId: number) => void;
   };
 }
 
@@ -55,6 +58,19 @@ export const WebGPUCanvas = ({
   const viewRef = useRef(null);
   const [contextId] = useState(() => generateContextId());
 
+  // Retire the native registry entry for this contextId on unmount. When a
+  // native surface is still attached, this is a no-op and the native view's
+  // own teardown retires the entry instead — which keeps StrictMode's
+  // simulated unmount (which re-runs effects without unmounting native views)
+  // from orphaning a live surface.
+  useEffect(() => {
+    return () => {
+      if (typeof RNWebGPU !== "undefined") {
+        RNWebGPU.destroyContext(contextId);
+      }
+    };
+  }, [contextId]);
+
   useImperativeHandle(ref, () => ({
     getContextId: () => contextId,
     getNativeSurface: () => {

package/cpp/api/JsiSkHostObjects.h

@@ -1,257 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "jsi/JsiHostObject.h"
-#include "utils/RNSkLog.h"
-#include "rnskia/RNSkPlatformContext.h"
-
-namespace RNSkia {
-
-namespace jsi = facebook::jsi;
-
-// Minimum memory pressure reported for any host object.
-// This accounts for C++ wrapper overhead and ensures dispose() never
-// increases reported memory pressure (which would defeat its purpose).
-static constexpr size_t kMinMemoryPressure = 256;
-
-/**
- * Base class for jsi host objects - these are all implemented as JsiHostObjects
- * and has a pointer to the platform context.
- */
-class JsiSkHostObject : public RNJsi::JsiHostObject {
-public:
-  /**
-   * Default constructor
-   * @param context Platform context
-   */
-  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;
-
-  /**
-   * Returns the type name of the host object.
-   */
-  virtual std::string getObjectType() const = 0;
-
-protected:
-  /**
-   * @return A pointer to the platform context
-   */
-  std::shared_ptr<RNSkPlatformContext> getContext() { return _context; }
-
-private:
-  std::shared_ptr<RNSkPlatformContext> _context;
-};
-
-#define JSI_API_TYPENAME(A)                                                    \
-  JSI_PROPERTY_GET(__typename__) {                                             \
-    return jsi::String::createFromUtf8(runtime, #A);                           \
-  }
-
-#define EXPORT_JSI_API_TYPENAME(CLASS, TYPENAME)                               \
-  JSI_API_TYPENAME(TYPENAME)                                                   \
-  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(CLASS, __typename__))
-
-// Define this macro to enable memory pressure debug logging
-// #define RNSKIA_DEBUG_MEMORY_PRESSURE
-
-#ifdef RNSKIA_DEBUG_MEMORY_PRESSURE
-// Version with debug logging
-#define JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(                           \
-    runtime, hostObjectInstance, context)                                      \
-  [&]() {                                                                      \
-    auto result =                                                              \
-        jsi::Object::createFromHostObject(runtime, hostObjectInstance);        \
-    auto memoryPressure = hostObjectInstance->getMemoryPressure();             \
-    const void *hostObjectId =                                                 \
-        static_cast<const void *>(hostObjectInstance.get());                   \
-    const char *mpUnit = "bytes";                                              \
-    double mpValue = static_cast<double>(memoryPressure);                      \
-    if (memoryPressure >= 1024ULL * 1024ULL) {                                 \
-      mpUnit = "MB";                                                           \
-      mpValue /= (1024.0 * 1024.0);                                            \
-      RNSkLogger::logToConsole(                                                \
-          "Host object %s (id=%p) memory pressure %.2f %s",                    \
-          hostObjectInstance->getObjectType().c_str(), hostObjectId, mpValue,  \
-          mpUnit);                                                             \
-    } else if (memoryPressure >= 1024ULL) {                                    \
-      mpUnit = "KB";                                                           \
-      mpValue /= 1024.0;                                                       \
-      RNSkLogger::logToConsole(                                                \
-          "Host object %s (id=%p) memory pressure %.2f %s",                    \
-          hostObjectInstance->getObjectType().c_str(), hostObjectId, mpValue,  \
-          mpUnit);                                                             \
-    } else {                                                                   \
-      RNSkLogger::logToConsole(                                                \
-          "Host object %s (id=%p) memory pressure %zu %s",                     \
-          hostObjectInstance->getObjectType().c_str(), hostObjectId,           \
-          memoryPressure, mpUnit);                                             \
-    }                                                                          \
-    if (memoryPressure > 0) {                                                  \
-      result.setExternalMemoryPressure(runtime, memoryPressure);               \
-    }                                                                          \
-    return result;                                                             \
-  }()
-#else
-// Version without debug logging (optimized)
-#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;                                                             \
-  }()
-#endif
-
-template <typename T> class JsiSkWrappingHostObject : public JsiSkHostObject {
-public:
-  /**
-   * Default constructor
-   * @param context Platform context
-   */
-  JsiSkWrappingHostObject(std::shared_ptr<RNSkPlatformContext> context,
-                          T object)
-      : JsiSkHostObject(std::move(context)), _object(std::move(object)) {}
-
-  /**
-   * Returns the underlying object exposed by this host object. This object
-   * should be wrapped in a shared pointer of some kind.
-   * Throws if the object has been disposed.
-   * @return Underlying object
-   */
-  T getObject() { return validateObject(); }
-  const T getObject() const { return validateObject(); }
-
-  /**
-   * Updates the inner object with a new version of the object.
-   */
-  void setObject(T object) { _object = object; }
-
-  /**
-   * Dispose function that can be exposed to JS by using the JSI_API_TYPENAME
-   * macro.
-   */
-  JSI_HOST_FUNCTION(dispose) {
-    if (!isDisposed()) {
-      thisValue.asObject(runtime).setExternalMemoryPressure(runtime,
-                                                            kMinMemoryPressure);
-    }
-    safeDispose();
-    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;
-
-  /**
-   * Returns true if the object has been disposed.
-   */
-  bool isDisposed() const {
-    return _isDisposed.load(std::memory_order_acquire);
-  }
-
-  /**
-   * Returns the underlying object without checking if disposed.
-   * Use this in destructors and releaseResources() where we need to access
-   * the object even after dispose() was called.
-   */
-  T getObjectUnchecked() const { return _object; }
-
-private:
-  /**
-   * Validates that _object was not disposed and returns it.
-   */
-  T validateObject() const {
-    if (_isDisposed.load(std::memory_order_acquire)) {
-      throw std::runtime_error("Attempted to access a disposed object.");
-    }
-    return _object;
-  }
-
-  void safeDispose() {
-    bool expected = false;
-    if (_isDisposed.compare_exchange_strong(expected, true,
-                                            std::memory_order_acq_rel)) {
-      releaseResources();
-    }
-  }
-
-  /**
-   * Wrapped object.
-   */
-  T _object;
-
-  /**
-   * Resource disposed flag.
-   */
-  std::atomic<bool> _isDisposed = {false};
-};
-
-template <typename T>
-class JsiSkWrappingSharedPtrHostObject
-    : public JsiSkWrappingHostObject<std::shared_ptr<T>> {
-public:
-  JsiSkWrappingSharedPtrHostObject(std::shared_ptr<RNSkPlatformContext> context,
-                                   std::shared_ptr<T> object)
-      : JsiSkWrappingHostObject<std::shared_ptr<T>>(std::move(context),
-                                                    std::move(object)) {}
-
-  /**
-    Returns the underlying object from a host object of this type
-   */
-  static std::shared_ptr<T> fromValue(jsi::Runtime &runtime,
-                                      const jsi::Value &obj) {
-    return std::static_pointer_cast<JsiSkWrappingSharedPtrHostObject>(
-               obj.asObject(runtime).asHostObject(runtime))
-        ->getObject();
-  }
-
-protected:
-  void releaseResources() override {
-    // Clear internally allocated objects
-    this->setObject(nullptr);
-  }
-};
-
-template <typename T>
-class JsiSkWrappingSkPtrHostObject : public JsiSkWrappingHostObject<sk_sp<T>> {
-public:
-  JsiSkWrappingSkPtrHostObject(std::shared_ptr<RNSkPlatformContext> context,
-                               sk_sp<T> object)
-      : JsiSkWrappingHostObject<sk_sp<T>>(std::move(context),
-                                          std::move(object)) {}
-
-  /**
-    Returns the underlying object from a host object of this type
-   */
-  static sk_sp<T> fromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
-    return std::static_pointer_cast<JsiSkWrappingSkPtrHostObject>(
-               obj.asObject(runtime).asHostObject(runtime))
-        ->getObject();
-  }
-
-protected:
-  void releaseResources() override {
-    // Clear internally allocated objects
-    this->setObject(nullptr);
-  }
-};
-
-} // namespace RNSkia

package/cpp/dawn/include/dawn/dawn_proc.h

@@ -1,53 +0,0 @@
-// Copyright 2019 The Dawn & Tint Authors
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this
-//    list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice,
-//    this list of conditions and the following disclaimer in the documentation
-//    and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its
-//    contributors may be used to endorse or promote products derived from
-//    this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#ifndef INCLUDE_DAWN_DAWN_PROC_H_
-#define INCLUDE_DAWN_DAWN_PROC_H_
-
-#include <webgpu/webgpu.h>
-
-#include "dawn/dawn_proc_table.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Sets the static proctable used by libdawn_proc to implement the Dawn entrypoints. Passing NULL
-// for `procs` sets up the null proctable that contains only null function pointers. It is the
-// default value of the proctable. Setting the proctable back to null is good practice when you
-// are done using libdawn_proc since further usage will cause a segfault instead of calling an
-// unexpected function.
-WGPU_EXPORT void dawnProcSetProcs(const DawnProcTable* procs);
-
-// Returns the static array of uint8_t of size 20 representing the Dawn version.
-WGPU_EXPORT const uint8_t* dawnProcGetVersion();
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#endif  // INCLUDE_DAWN_DAWN_PROC_H_