react-native 0.71.6 → 0.72.0-rc.1

package/ReactCommon/jsiexecutor/jsireact/JSIExecutor.h

@@ -15,6 +15,7 @@
 #include <jsi/jsi.h>
 #include <functional>
 #include <mutex>
+#include <optional>
 
 namespace facebook {
 namespace react {
@@ -127,18 +128,17 @@ class JSIExecutor : public JSExecutor {
   JSIScopedTimeoutInvoker scopedTimeoutInvoker_;
   RuntimeInstaller runtimeInstaller_;
 
-  folly::Optional<jsi::Function> callFunctionReturnFlushedQueue_;
-  folly::Optional<jsi::Function> invokeCallbackAndReturnFlushedQueue_;
-  folly::Optional<jsi::Function> flushedQueue_;
+  std::optional<jsi::Function> callFunctionReturnFlushedQueue_;
+  std::optional<jsi::Function> invokeCallbackAndReturnFlushedQueue_;
+  std::optional<jsi::Function> flushedQueue_;
 };
 
 using Logger =
     std::function<void(const std::string &message, unsigned int logLevel)>;
 void bindNativeLogger(jsi::Runtime &runtime, Logger logger);
 
-using PerformanceNow = std::function<double()>;
-void bindNativePerformanceNow(
-    jsi::Runtime &runtime,
-    PerformanceNow performanceNow);
+void bindNativePerformanceNow(jsi::Runtime &runtime);
+
+double performanceNow();
 } // namespace react
 } // namespace facebook

package/ReactCommon/jsiexecutor/jsireact/JSINativeModules.cpp

@@ -45,7 +45,7 @@ Value JSINativeModules::getModule(Runtime &rt, const PropNameID &name) {
   }
 
   auto module = createModule(rt, moduleName);
-  if (!module.hasValue()) {
+  if (!module.has_value()) {
     BridgeNativeModulePerfLogger::moduleJSRequireEndingFail(moduleName.c_str());
     // Allow lookup to continue in the objects own properties, which allows for
     // overrides of NativeModules
@@ -61,14 +61,14 @@ Value JSINativeModules::getModule(Runtime &rt, const PropNameID &name) {
 }
 
 void JSINativeModules::reset() {
-  m_genNativeModuleJS = folly::none;
+  m_genNativeModuleJS = std::nullopt;
   m_objects.clear();
 }
 
-folly::Optional<Object> JSINativeModules::createModule(
+std::optional<Object> JSINativeModules::createModule(
     Runtime &rt,
     const std::string &name) {
-  bool hasLogger(ReactMarker::logTaggedMarker);
+  bool hasLogger(ReactMarker::logTaggedMarkerImpl);
   if (hasLogger) {
     ReactMarker::logTaggedMarker(
         ReactMarker::NATIVE_MODULE_SETUP_START, name.c_str());
@@ -80,8 +80,8 @@ folly::Optional<Object> JSINativeModules::createModule(
   }
 
   auto result = m_moduleRegistry->getConfig(name);
-  if (!result.hasValue()) {
-    return folly::none;
+  if (!result.has_value()) {
+    return std::nullopt;
   }
 
   Value moduleInfo = m_genNativeModuleJS->call(
@@ -92,7 +92,7 @@ folly::Optional<Object> JSINativeModules::createModule(
   CHECK(moduleInfo.isObject())
       << "Module returned from genNativeModule isn't an Object";
 
-  folly::Optional<Object> module(
+  std::optional<Object> module(
       moduleInfo.asObject(rt).getPropertyAsObject(rt, "module"));
 
   if (hasLogger) {

package/ReactCommon/jsiexecutor/jsireact/JSINativeModules.h

@@ -11,8 +11,8 @@
 #include <string>
 
 #include <cxxreact/ModuleRegistry.h>
-#include <folly/Optional.h>
 #include <jsi/jsi.h>
+#include <optional>
 
 namespace facebook {
 namespace react {
@@ -27,11 +27,11 @@ class JSINativeModules {
   void reset();
 
  private:
-  folly::Optional<jsi::Function> m_genNativeModuleJS;
+  std::optional<jsi::Function> m_genNativeModuleJS;
   std::shared_ptr<ModuleRegistry> m_moduleRegistry;
   std::unordered_map<std::string, jsi::Object> m_objects;
 
-  folly::Optional<jsi::Object> createModule(
+  std::optional<jsi::Object> createModule(
       jsi::Runtime &rt,
       const std::string &name);
 };

package/ReactCommon/jsinspector/.clang-tidy

@@ -2,4 +2,5 @@
 Checks: '>
 clang-diagnostic-*,
 '
+InheritParentConfig: true
 ...

package/ReactCommon/jsinspector/CMakeLists.txt

@@ -6,7 +6,9 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(-fexceptions)
+add_compile_options(
+        -fexceptions
+        -std=c++17)
 
 file(GLOB jsinspector_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(jsinspector SHARED ${jsinspector_SRC})

package/ReactCommon/jsinspector/React-jsinspector.podspec

@@ -22,9 +22,10 @@ Pod::Spec.new do |s|
   s.summary                = "-"  # TODO
   s.homepage               = "https://reactnative.dev/"
   s.license                = package["license"]
-  s.author                 = "Facebook, Inc. and its affiliates"
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = { :ios => "12.4" }
   s.source                 = source
   s.source_files           = "*.{cpp,h}"
   s.header_dir             = 'jsinspector'
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++17" }
 end

package/ReactCommon/libraries/fbcore/src/test/java/com/facebook/powermock/BUCK

@@ -35,7 +35,7 @@ rn_android_library(
 rn_prebuilt_jar(
     name = "byte-buddy",
     binary_jar = ":byte-buddy-binary.jar",
-    visibility = ["//ReactAndroid/..."],
+    visibility = ["//packages/react-native/ReactAndroid/..."],
 )
 
 fb_native.remote_file(
@@ -47,7 +47,7 @@ fb_native.remote_file(
 rn_prebuilt_jar(
     name = "byte-buddy-agent",
     binary_jar = ":byte-buddy-agent-binary.jar",
-    visibility = ["//ReactAndroid/..."],
+    visibility = ["//packages/react-native/ReactAndroid/..."],
 )
 
 fb_native.remote_file(
@@ -59,7 +59,7 @@ fb_native.remote_file(
 rn_prebuilt_jar(
     name = "objenesis",
     binary_jar = ":objenesis-binary.jar",
-    visibility = ["//ReactAndroid/..."],
+    visibility = ["//packages/react-native/ReactAndroid/..."],
 )
 
 fb_native.remote_file(

package/ReactCommon/logger/React-logger.podspec

@@ -27,7 +27,7 @@ Pod::Spec.new do |s|
   s.summary                = "-"  # TODO
   s.homepage               = "https://reactnative.dev/"
   s.license                = package["license"]
-  s.author                 = "Facebook, Inc. and its affiliates"
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = { :ios => "12.4" }
   s.source                 = source
   s.source_files           = "*.{cpp,h}"

package/ReactCommon/react/bridging/BUCK

@@ -50,8 +50,7 @@ fb_xplat_cxx_test(
     contacts = ["oncall+react_native@xmail.facebook.com"],
     platforms = (ANDROID, APPLE, CXX),
     deps = [
-        ":bridging",
+        ":testlib",
         "//xplat/hermes/API:HermesAPI",
-        "//xplat/third-party/gmock:gtest",
     ],
 )

package/ReactCommon/react/bridging/Base.h

@@ -10,7 +10,7 @@
 #include <react/bridging/Convert.h>
 
 #include <ReactCommon/CallInvoker.h>
-#include <folly/Function.h>
+#include <butter/function.h>
 #include <jsi/jsi.h>
 
 #include <cstdint>
@@ -36,12 +36,12 @@ struct function_wrapper;
 
 template <typename C, typename R, typename... Args>
 struct function_wrapper<R (C::*)(Args...)> {
-  using type = folly::Function<R(Args...)>;
+  using type = butter::function<R(Args...)>;
 };
 
 template <typename C, typename R, typename... Args>
 struct function_wrapper<R (C::*)(Args...) const> {
-  using type = folly::Function<R(Args...)>;
+  using type = butter::function<R(Args...)>;
 };
 
 template <typename T, typename = void>

package/ReactCommon/react/bridging/CallbackWrapper.h

@@ -22,25 +22,10 @@ class CallbackWrapper : public LongLivedObject {
       jsi::Function &&callback,
       jsi::Runtime &runtime,
       std::shared_ptr<CallInvoker> jsInvoker)
-      : longLivedObjectCollection_(),
-        callback_(std::move(callback)),
+      : callback_(std::move(callback)),
         runtime_(runtime),
         jsInvoker_(std::move(jsInvoker)) {}
 
-  CallbackWrapper(
-      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
-      jsi::Function &&callback,
-      jsi::Runtime &runtime,
-      std::shared_ptr<CallInvoker> jsInvoker)
-      : longLivedObjectCollection_(longLivedObjectCollection),
-        callback_(std::move(callback)),
-        runtime_(runtime),
-        jsInvoker_(std::move(jsInvoker)) {}
-
-  // Use a weak_ptr to avoid a retain cycle: LongLivedObjectCollection owns all
-  // CallbackWrappers. So, CallbackWrapper cannot own its
-  // LongLivedObjectCollection.
-  std::weak_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
   jsi::Function callback_;
   jsi::Runtime &runtime_;
   std::shared_ptr<CallInvoker> jsInvoker_;
@@ -50,20 +35,9 @@ class CallbackWrapper : public LongLivedObject {
       jsi::Function &&callback,
       jsi::Runtime &runtime,
       std::shared_ptr<CallInvoker> jsInvoker) {
-    auto wrapper = std::shared_ptr<CallbackWrapper>(
-        new CallbackWrapper(std::move(callback), runtime, jsInvoker));
-    LongLivedObjectCollection::get().add(wrapper);
-    return wrapper;
-  }
-
-  static std::weak_ptr<CallbackWrapper> createWeak(
-      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
-      jsi::Function &&callback,
-      jsi::Runtime &runtime,
-      std::shared_ptr<CallInvoker> jsInvoker) {
     auto wrapper = std::shared_ptr<CallbackWrapper>(new CallbackWrapper(
-        longLivedObjectCollection, std::move(callback), runtime, jsInvoker));
-    longLivedObjectCollection->add(wrapper);
+        std::move(callback), runtime, std::move(jsInvoker)));
+    LongLivedObjectCollection::get().add(wrapper);
     return wrapper;
   }
 
@@ -87,16 +61,6 @@ class CallbackWrapper : public LongLivedObject {
   std::shared_ptr<CallInvoker> jsInvokerPtr() {
     return jsInvoker_;
   }
-
-  void allowRelease() override {
-    if (auto longLivedObjectCollection = longLivedObjectCollection_.lock()) {
-      if (longLivedObjectCollection != nullptr) {
-        longLivedObjectCollection->remove(this);
-        return;
-      }
-    }
-    LongLivedObject::allowRelease();
-  }
 };
 
 } // namespace react

package/ReactCommon/react/bridging/Function.h

@@ -10,7 +10,9 @@
 #include <react/bridging/Base.h>
 #include <react/bridging/CallbackWrapper.h>
 
-#include <folly/Function.h>
+#include <ReactCommon/SchedulerPriority.h>
+
+#include <butter/function.h>
 
 namespace facebook::react {
 
@@ -37,23 +39,36 @@ class AsyncCallback {
   }
 
   void call(Args... args) const {
-    auto wrapper = callback_->wrapper_.lock();
-    if (!wrapper) {
-      throw std::runtime_error("Failed to call invalidated async callback");
-    }
-
-    auto argsTuple = std::make_tuple(std::forward<Args>(args)...);
+    callInternal(std::nullopt, std::forward<Args>(args)...);
+  }
 
-    wrapper->jsInvoker().invokeAsync(
-        [callback = callback_,
-         argsPtr = std::make_shared<decltype(argsTuple)>(
-             std::move(argsTuple))] { callback->apply(std::move(*argsPtr)); });
+  void callWithPriority(SchedulerPriority priority, Args... args) const {
+    callInternal(priority, std::forward<Args>(args)...);
   }
 
  private:
   friend Bridging<AsyncCallback>;
 
   std::shared_ptr<SyncCallback<void(Args...)>> callback_;
+
+  void callInternal(std::optional<SchedulerPriority> priority, Args... args)
+      const {
+    auto wrapper = callback_->wrapper_.lock();
+    if (!wrapper) {
+      throw std::runtime_error("Failed to call invalidated async callback");
+    }
+    auto fn = [callback = callback_,
+               argsPtr = std::make_shared<std::tuple<Args...>>(
+                   std::make_tuple(std::forward<Args>(args)...))] {
+      callback->apply(std::move(*argsPtr));
+    };
+
+    if (priority) {
+      wrapper->jsInvoker().invokeAsync(*priority, std::move(fn));
+    } else {
+      wrapper->jsInvoker().invokeAsync(std::move(fn));
+    }
+  }
 };
 
 template <typename R, typename... Args>
@@ -154,8 +169,8 @@ struct Bridging<SyncCallback<R(Args...)>> {
 };
 
 template <typename R, typename... Args>
-struct Bridging<folly::Function<R(Args...)>> {
-  using Func = folly::Function<R(Args...)>;
+struct Bridging<butter::function<R(Args...)>> {
+  using Func = butter::function<R(Args...)>;
   using IndexSequence = std::index_sequence_for<Args...>;
 
   static constexpr size_t kArgumentCount = sizeof...(Args);
@@ -202,13 +217,17 @@ struct Bridging<folly::Function<R(Args...)>> {
 };
 
 template <typename R, typename... Args>
-struct Bridging<std::function<R(Args...)>>
-    : Bridging<folly::Function<R(Args...)>> {};
+struct Bridging<
+    std::function<R(Args...)>,
+    std::enable_if_t<!std::is_same_v<
+        std::function<R(Args...)>,
+        butter::function<R(Args...)>>>>
+    : Bridging<butter::function<R(Args...)>> {};
 
 template <typename R, typename... Args>
-struct Bridging<R(Args...)> : Bridging<folly::Function<R(Args...)>> {};
+struct Bridging<R(Args...)> : Bridging<butter::function<R(Args...)>> {};
 
 template <typename R, typename... Args>
-struct Bridging<R (*)(Args...)> : Bridging<folly::Function<R(Args...)>> {};
+struct Bridging<R (*)(Args...)> : Bridging<butter::function<R(Args...)>> {};
 
 } // namespace facebook::react

package/ReactCommon/react/bridging/LongLivedObject.cpp

@@ -16,27 +16,22 @@ LongLivedObjectCollection &LongLivedObjectCollection::get() {
   return instance;
 }
 
-LongLivedObjectCollection::LongLivedObjectCollection() {}
-
-void LongLivedObjectCollection::add(std::shared_ptr<LongLivedObject> so) const {
+void LongLivedObjectCollection::add(std::shared_ptr<LongLivedObject> so) {
   std::lock_guard<std::mutex> lock(collectionMutex_);
-  collection_.insert(so);
+  collection_.insert(std::move(so));
 }
 
-void LongLivedObjectCollection::remove(const LongLivedObject *o) const {
+void LongLivedObjectCollection::remove(const LongLivedObject *o) {
   std::lock_guard<std::mutex> lock(collectionMutex_);
-  auto p = collection_.begin();
-  for (; p != collection_.end(); p++) {
+  for (auto p = collection_.begin(); p != collection_.end(); p++) {
     if (p->get() == o) {
+      collection_.erase(p);
       break;
     }
   }
-  if (p != collection_.end()) {
-    collection_.erase(p);
-  }
 }
 
-void LongLivedObjectCollection::clear() const {
+void LongLivedObjectCollection::clear() {
   std::lock_guard<std::mutex> lock(collectionMutex_);
   collection_.clear();
 }
@@ -47,8 +42,6 @@ size_t LongLivedObjectCollection::size() const {
 }
 
 // LongLivedObject
-LongLivedObject::LongLivedObject() {}
-LongLivedObject::~LongLivedObject() {}
 
 void LongLivedObject::allowRelease() {
   LongLivedObjectCollection::get().remove(this);

package/ReactCommon/react/bridging/LongLivedObject.h

@@ -26,11 +26,11 @@ namespace react {
  */
 class LongLivedObject {
  public:
-  virtual void allowRelease();
+  void allowRelease();
 
  protected:
-  LongLivedObject();
-  virtual ~LongLivedObject();
+  LongLivedObject() = default;
+  virtual ~LongLivedObject() = default;
 };
 
 /**
@@ -40,17 +40,18 @@ class LongLivedObjectCollection {
  public:
   static LongLivedObjectCollection &get();
 
-  LongLivedObjectCollection();
   LongLivedObjectCollection(LongLivedObjectCollection const &) = delete;
   void operator=(LongLivedObjectCollection const &) = delete;
 
-  void add(std::shared_ptr<LongLivedObject> o) const;
-  void remove(const LongLivedObject *o) const;
-  void clear() const;
+  void add(std::shared_ptr<LongLivedObject> o);
+  void remove(const LongLivedObject *o);
+  void clear();
   size_t size() const;
 
  private:
-  mutable std::unordered_set<std::shared_ptr<LongLivedObject>> collection_;
+  LongLivedObjectCollection() = default;
+
+  std::unordered_set<std::shared_ptr<LongLivedObject>> collection_;
   mutable std::mutex collectionMutex_;
 };
 

package/ReactCommon/react/bridging/Number.h

@@ -44,4 +44,15 @@ struct Bridging<int32_t> {
   }
 };
 
+template <>
+struct Bridging<uint32_t> {
+  static uint32_t fromJs(jsi::Runtime &, const jsi::Value &value) {
+    return (uint32_t)value.asNumber();
+  }
+
+  static jsi::Value toJs(jsi::Runtime &, uint32_t value) {
+    return (double)value;
+  }
+};
+
 } // namespace facebook::react

package/ReactCommon/react/bridging/tests/BridgingTest.cpp

@@ -60,6 +60,21 @@ TEST_F(BridgingTest, numberTest) {
   EXPECT_FLOAT_EQ(
       1.2f, static_cast<float>(bridging::toJs(rt, 1.2f).asNumber()));
   EXPECT_DOUBLE_EQ(1.2, bridging::toJs(rt, 1.2).asNumber());
+
+  EXPECT_EQ(
+      42,
+      static_cast<uint32_t>(
+          bridging::toJs(rt, static_cast<uint32_t>(42)).asNumber()));
+
+  EXPECT_EQ(
+      -42,
+      static_cast<uint32_t>(
+          bridging::toJs(rt, static_cast<uint32_t>(-42)).asNumber()));
+
+  EXPECT_FALSE(
+      -42 ==
+      static_cast<int32_t>(
+          bridging::toJs(rt, static_cast<uint32_t>(-42)).asNumber()));
 }
 
 TEST_F(BridgingTest, stringTest) {
@@ -405,7 +420,7 @@ TEST_F(BridgingTest, pointerTest) {
   auto str = "hi"s;
   auto unique = std::make_unique<std::string>(str);
   auto shared = std::make_shared<std::string>(str);
-  auto weak = std::weak_ptr(shared);
+  auto weak = std::weak_ptr<std::string>(shared);
 
   EXPECT_EQ(str, bridging::toJs(rt, unique, invoker).asString(rt).utf8(rt));
   EXPECT_EQ(str, bridging::toJs(rt, shared, invoker).asString(rt).utf8(rt));

package/ReactCommon/react/config/.clang-tidy

@@ -2,4 +2,5 @@
 Checks: '>
 clang-diagnostic-*,
 '
+InheritParentConfig: true
 ...

package/ReactCommon/react/config/ReactNativeConfig.cpp

@@ -21,6 +21,12 @@ ReactNativeConfig::~ReactNativeConfig() {}
 EmptyReactNativeConfig::EmptyReactNativeConfig() {}
 
 bool EmptyReactNativeConfig::getBool(const std::string &param) const {
+  if (param == "react_fabric:enabled_layout_animations_ios") {
+    return true;
+  }
+  if (param == "react_fabric:enable_nstextstorage_caching") {
+    return true;
+  }
   return false;
 }
 

package/ReactCommon/react/config/ReactNativeConfig.h

@@ -28,7 +28,7 @@ class ReactNativeConfig {
 };
 
 /**
- * Empty configuration that will always provide "falsy" values.
+ * Empty configuration that will provide hardcoded values.
  */
 class EmptyReactNativeConfig : public ReactNativeConfig {
  public:

package/ReactCommon/react/debug/CMakeLists.txt

@@ -22,3 +22,7 @@ add_library(react_debug SHARED ${react_debug_SRC})
 target_include_directories(react_debug PUBLIC ${REACT_COMMON_DIR})
 
 target_link_libraries(react_debug log folly_runtime)
+
+if(${CMAKE_BUILD_TYPE} MATCHES Release)
+        target_compile_options(react_debug PUBLIC -DNDEBUG)
+endif()

package/ReactCommon/react/debug/flags.h

@@ -10,7 +10,9 @@
 //
 // Enable REACT_NATIVE_DEBUG if NDEBUG is not defined.
 // Due to BUCK defaults in open-source, NDEBUG is always defined for all android
-// builds (if you build without BUCK, this isn't an issue). Thus we introduce
+// builds.
+// If you build in OSS with CMake, you will have -DNDEBUG set only for release
+// builds, therefore REACT_NATIVE_DEBUG will not be set. Here we introduce
 // REACT_NATIVE_DEBUG that we use internally instead of NDEBUG that we can
 // control and use as a more reliable xplat flag. For any build that doesn't
 // have NDEBUG defined, we enable REACT_NATIVE_DEBUG for convenience.

package/ReactCommon/react/debug/react_native_assert.h

@@ -12,6 +12,12 @@
 // test before moving on. When all issues have been found, maybe we can use
 // `UNDEBUG` flag to disable NDEBUG in debug builds on Android.
 
+// Asserting is appropriate for conditions that:
+//   1. May or may not be recoverable, and
+//   2. imply there is a bug in React Native when violated.
+// For recoverable conditions that can be violated by user mistake (e.g. JS
+// code passes an unexpected prop value), consider react_native_expect instead.
+
 #include "flags.h"
 
 #undef react_native_assert

package/ReactCommon/react/debug/react_native_expect.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// No header guards since it is legitimately possible to include this file more
+// than once with and without REACT_NATIVE_DEBUG.
+
+// react_native_expect is a non-fatal counterpart of react_native_assert.
+// In debug builds, when an expectation fails, we log and move on.
+// In release builds, react_native_expect is a noop.
+
+// react_native_expect is appropriate for recoverable conditions that can be
+// violated by user mistake (e.g. JS code passes an unexpected prop value).
+// To enforce invariants that are internal to React Native, consider
+// react_native_assert (or a stronger mechanism).
+// Calling react_native_expect does NOT, by itself, guarantee that the user
+// will see a helpful diagnostic (beyond a low level log). That concern is the
+// caller's responsibility.
+
+#include "flags.h"
+
+#undef react_native_expect
+
+#ifndef REACT_NATIVE_DEBUG
+
+#define react_native_expect(e) ((void)0)
+
+#else // REACT_NATIVE_DEBUG
+
+#include <glog/logging.h>
+#include <cassert>
+
+#define react_native_expect(cond)                           \
+  if (!(cond)) {                                            \
+    LOG(ERROR) << "react_native_expect failure: " << #cond; \
+  }
+
+#endif // REACT_NATIVE_DEBUG

package/ReactCommon/react/nativemodule/.clang-tidy

@@ -2,4 +2,5 @@
 Checks: '>
 clang-diagnostic-*,
 '
+InheritParentConfig: true
 ...

package/ReactCommon/react/nativemodule/core/BUCK

@@ -1,5 +1,7 @@
 load("//tools/build_defs/oss:rn_defs.bzl", "ANDROID", "APPLE", "CXX", "FBJNI_TARGET", "get_objc_arc_preprocessor_flags", "get_preprocessor_flags_for_build_mode", "get_static_library_ios_flags", "react_native_target", "react_native_xplat_shared_library_target", "react_native_xplat_target", "rn_xplat_cxx_library", "subdir_glob")
 
+oncall("react_native")
+
 rn_xplat_cxx_library(
     name = "core",
     srcs = glob(
@@ -43,7 +45,7 @@ rn_xplat_cxx_library(
     ],
     ios_exported_headers = subdir_glob(
         [
-            ("platform/ios", "*.h"),
+            ("platform/ios/ReactCommon", "*.h"),
         ],
         prefix = "ReactCommon",
     ),

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboCxxModule.cpp

@@ -111,7 +111,12 @@ jsi::Value TurboCxxModule::get(
 
   // If we have a JS wrapper, cache the result of this lookup
   if (jsRepresentation_) {
-    jsRepresentation_->setProperty(runtime, propName, result);
+    auto jsRepresentation = jsRepresentation_->lock(runtime);
+    if (!jsRepresentation.isUndefined()) {
+      std::move(jsRepresentation)
+          .asObject(runtime)
+          .setProperty(runtime, propName, result);
+    }
   }
 
   return result;