react-native-windows 0.76.3 → 0.77.0-preview.2

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/LongLivedObject.h

@@ -0,0 +1,61 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <unordered_set>
+
+namespace facebook::react {
+
+/**
+ * A simple wrapper class that can be registered to a collection that keep it
+ * alive for extended period of time. This object can be removed from the
+ * collection when needed.
+ *
+ * The subclass of this class must be created using std::make_shared<T>().
+ * After creation, add it to the `LongLivedObjectCollection`. When done with the
+ * object, call `allowRelease()` to reclaim its memory.
+ *
+ * When using LongLivedObject to keep JS values alive, ensure you only hold weak
+ * references to the object outside the JS thread to avoid accessing deallocated
+ * values when the JS VM is shutdown.
+ */
+class LongLivedObject {
+ public:
+  virtual void allowRelease();
+
+ protected:
+  explicit LongLivedObject(jsi::Runtime& runtime) : runtime_(runtime) {}
+  virtual ~LongLivedObject() = default;
+  jsi::Runtime& runtime_;
+};
+
+/**
+ * A singleton, thread-safe, write-only collection for the `LongLivedObject`s.
+ */
+class LongLivedObjectCollection {
+ public:
+  static LongLivedObjectCollection& get(jsi::Runtime& runtime);
+
+  LongLivedObjectCollection() = default;
+  LongLivedObjectCollection(const LongLivedObjectCollection&) = delete;
+  void operator=(const LongLivedObjectCollection&) = delete;
+
+  void add(std::shared_ptr<LongLivedObject> o);
+  void remove(const LongLivedObject* o);
+  void clear();
+  size_t size() const;
+
+ private:
+  std::unordered_set<std::shared_ptr<LongLivedObject>> collection_;
+  mutable std::mutex collectionMutex_;
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/Object.h

@@ -0,0 +1,93 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/bridging/AString.h>
+#include <react/bridging/Base.h>
+
+#include <map>
+#include <unordered_map>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<jsi::WeakObject> {
+  static jsi::WeakObject fromJs(jsi::Runtime& rt, const jsi::Object& value) {
+    return jsi::WeakObject(rt, value);
+  }
+
+  static jsi::Value toJs(jsi::Runtime& rt, jsi::WeakObject& value) {
+    return value.lock(rt);
+  }
+};
+
+template <typename T>
+struct Bridging<
+    std::shared_ptr<T>,
+    std::enable_if_t<std::is_base_of_v<jsi::HostObject, T>>> {
+  static std::shared_ptr<T> fromJs(jsi::Runtime& rt, const jsi::Object& value) {
+    return value.getHostObject<T>(rt);
+  }
+
+  static jsi::Object toJs(jsi::Runtime& rt, std::shared_ptr<T> value) {
+    return jsi::Object::createFromHostObject(rt, std::move(value));
+  }
+};
+
+namespace map_detail {
+
+template <typename T>
+struct Bridging {
+  static T fromJs(
+      jsi::Runtime& rt,
+      const jsi::Object& value,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    T result;
+    auto propertyNames = value.getPropertyNames(rt);
+    auto length = propertyNames.length(rt);
+
+    for (size_t i = 0; i < length; i++) {
+      auto propertyName = propertyNames.getValueAtIndex(rt, i);
+
+      result.emplace(
+          bridging::fromJs<std::string>(rt, propertyName, jsInvoker),
+          bridging::fromJs<typename T::mapped_type>(
+              rt, value.getProperty(rt, propertyName.asString(rt)), jsInvoker));
+    }
+
+    return result;
+  }
+
+  static jsi::Object toJs(
+      jsi::Runtime& rt,
+      const T& map,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    auto resultObject = jsi::Object(rt);
+
+    for (const auto& [key, value] : map) {
+      resultObject.setProperty(
+          rt,
+          jsi::PropNameID::forUtf8(rt, key),
+          bridging::toJs(rt, value, jsInvoker));
+    }
+
+    return resultObject;
+  }
+};
+
+} // namespace map_detail
+
+template <typename... Args>
+struct Bridging<std::map<std::string, Args...>>
+    : map_detail::Bridging<std::map<std::string, Args...>> {};
+
+template <typename... Args>
+struct Bridging<std::unordered_map<std::string, Args...>>
+    : map_detail::Bridging<std::unordered_map<std::string, Args...>> {};
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/Promise.h

@@ -0,0 +1,104 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/bridging/Error.h>
+#include <react/bridging/Function.h>
+#include <react/bridging/LongLivedObject.h>
+
+#include <mutex>
+#include <optional>
+
+namespace facebook::react {
+
+template <typename T>
+class AsyncPromise {
+ public:
+  AsyncPromise(jsi::Runtime& rt, const std::shared_ptr<CallInvoker>& jsInvoker)
+      : state_(std::make_shared<SharedState>()) {
+    auto constructor = rt.global().getPropertyAsFunction(rt, "Promise");
+
+    auto promise = constructor.callAsConstructor(
+        rt,
+        bridging::toJs(
+            rt,
+            // Safe to capture this since this is called synchronously.
+            [this](AsyncCallback<T> resolve, AsyncCallback<Error> reject) {
+              state_->resolve = std::move(resolve);
+              state_->reject = std::move(reject);
+            },
+            jsInvoker));
+
+    auto promiseHolder =
+        std::make_shared<PromiseHolder>(rt, promise.asObject(rt));
+    LongLivedObjectCollection::get(rt).add(promiseHolder);
+
+    // The shared state can retain the promise holder weakly now.
+    state_->promiseHolder = promiseHolder;
+  }
+
+  void resolve(T value) {
+    std::lock_guard<std::mutex> lock(state_->mutex);
+
+    if (state_->resolve) {
+      state_->resolve->call(std::move(value));
+      state_->resolve.reset();
+      state_->reject.reset();
+    }
+  }
+
+  void reject(Error error) {
+    std::lock_guard<std::mutex> lock(state_->mutex);
+
+    if (state_->reject) {
+      state_->reject->call(std::move(error));
+      state_->reject.reset();
+      state_->resolve.reset();
+    }
+  }
+
+  jsi::Object get(jsi::Runtime& rt) const {
+    if (auto holder = state_->promiseHolder.lock()) {
+      return jsi::Value(rt, holder->promise).asObject(rt);
+    } else {
+      throw jsi::JSError(rt, "Failed to get invalidated promise");
+    }
+  }
+
+ private:
+  struct PromiseHolder : LongLivedObject {
+    PromiseHolder(jsi::Runtime& runtime, jsi::Object p)
+        : LongLivedObject(runtime), promise(std::move(p)) {}
+
+    jsi::Object promise;
+  };
+
+  struct SharedState {
+    ~SharedState() {
+      if (auto holder = promiseHolder.lock()) {
+        holder->allowRelease();
+      }
+    }
+
+    std::mutex mutex;
+    std::weak_ptr<PromiseHolder> promiseHolder;
+    std::optional<AsyncCallback<T>> resolve;
+    std::optional<AsyncCallback<Error>> reject;
+  };
+
+  std::shared_ptr<SharedState> state_;
+};
+
+template <typename T>
+struct Bridging<AsyncPromise<T>> {
+  static jsi::Object toJs(jsi::Runtime& rt, const AsyncPromise<T>& promise) {
+    return promise.get(rt);
+  }
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/Value.h

@@ -0,0 +1,107 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+
+#include <memory>
+#include <optional>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<std::nullptr_t> {
+  static std::nullptr_t fromJs(jsi::Runtime& rt, const jsi::Value& value) {
+    if (value.isNull() || value.isUndefined()) {
+      return nullptr;
+    } else {
+      throw jsi::JSError(rt, "Cannot convert value to nullptr");
+    }
+  }
+
+  static std::nullptr_t toJs(jsi::Runtime&, std::nullptr_t) {
+    return nullptr;
+  }
+};
+
+template <typename T>
+struct Bridging<std::optional<T>> {
+  static std::optional<T> fromJs(
+      jsi::Runtime& rt,
+      const jsi::Value& value,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    if (value.isNull() || value.isUndefined()) {
+      return {};
+    }
+    return bridging::fromJs<T>(rt, value, jsInvoker);
+  }
+
+  template <typename U>
+  static std::optional<T> fromJs(
+      jsi::Runtime& rt,
+      const std::optional<U>& value,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    if (value) {
+      return bridging::fromJs<T>(rt, *value, jsInvoker);
+    }
+    return {};
+  }
+
+  static jsi::Value toJs(
+      jsi::Runtime& rt,
+      const std::optional<T>& value,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    if (value) {
+      return bridging::toJs(rt, *value, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+template <typename T>
+struct Bridging<
+    std::shared_ptr<T>,
+    std::enable_if_t<!std::is_base_of_v<jsi::HostObject, T>>> {
+  static jsi::Value toJs(
+      jsi::Runtime& rt,
+      const std::shared_ptr<T>& ptr,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    if (ptr) {
+      return bridging::toJs(rt, *ptr, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+template <typename T>
+struct Bridging<std::unique_ptr<T>> {
+  static jsi::Value toJs(
+      jsi::Runtime& rt,
+      const std::unique_ptr<T>& ptr,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    if (ptr) {
+      return bridging::toJs(rt, *ptr, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+template <typename T>
+struct Bridging<std::weak_ptr<T>> {
+  static jsi::Value toJs(
+      jsi::Runtime& rt,
+      const std::weak_ptr<T>& weakPtr,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    if (auto ptr = weakPtr.lock()) {
+      return bridging::toJs(rt, *ptr, jsInvoker);
+    }
+    return jsi::Value::null();
+  }
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/debug/flags.h

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+//
+// Preprocessor flags which control whether code meant for debugging the
+// internals of React Native is included in the build. E.g. debug assertions.
+//
+// This flag is normally derived from NDEBUG, but may be set explicitly by
+// defining `REACT_NATIVE_DEBUG` or `REACT_NATIVE_PRODUCTION`.
+#if !(defined(REACT_NATIVE_DEBUG) || defined(REACT_NATIVE_PRODUCTION))
+#ifdef NDEBUG
+#define REACT_NATIVE_PRODUCTION
+#else
+#define REACT_NATIVE_DEBUG
+#endif
+#endif

package/Microsoft.ReactNative.Cxx/ReactCommon/react/debug/react_native_assert.h

@@ -0,0 +1,72 @@
+/*
+ * 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_assert allows us to opt-in to specific asserts on Android and
+// 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.
+
+#pragma once
+
+#include "flags.h"
+
+#undef react_native_assert
+
+#ifndef REACT_NATIVE_DEBUG
+
+#define react_native_assert(e) ((void)0)
+
+#else // REACT_NATIVE_DEBUG
+
+#ifdef __ANDROID__
+
+#include <android/log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+void react_native_assert_fail(
+    const char* func,
+    const char* file,
+    int line,
+    const char* expr);
+#ifdef __cplusplus
+}
+#endif // __cpusplus
+
+#define react_native_assert(e) \
+  ((e) ? (void)0 : react_native_assert_fail(__func__, __FILE__, __LINE__, #e))
+
+#else // __ANDROID__
+
+#include <glog/logging.h>
+#include <cassert>
+
+// For all platforms, but iOS+Xcode especially: flush logs because some might be
+// lost on iOS if an assert is hit right after this. If you are trying to debug
+// something actively and have added lots of LOG statements to track down an
+// issue, there is race between flushing the final logs and stopping execution
+// when the assert hits. Thus, if we know an assert will fail, we force flushing
+// to happen right before the assert.
+#define react_native_assert(cond)                           \
+  if (!(cond)) {                                            \
+    LOG(ERROR) << "react_native_assert failure: " << #cond; \
+    google::FlushLogFiles(google::GLOG_INFO);               \
+    assert(cond);                                           \
+  }
+
+#endif // platforms besides __ANDROID__
+
+#endif // REACT_NATIVE_DEBUG