react-native-windows 0.75.3 → 0.76.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/jsinspector-modern/NetworkIOAgent.h

@@ -0,0 +1,266 @@
+/*
+ * 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 "CdpJson.h"
+#include "InspectorInterfaces.h"
+#include "ScopedExecutor.h"
+
+#include <folly/dynamic.h>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+
+namespace facebook::react::jsinspector_modern {
+
+using StreamID = const std::string;
+using Headers = std::map<std::string, std::string>;
+using IOReadError = const std::string;
+
+// namespace { [Windows #13587]
+class Stream; // Defined in NetworkIOAgent.cpp
+using StreamsMap = std::unordered_map<std::string, std::shared_ptr<Stream>>;
+// } // namespace [Windows #13587]
+
+struct LoadNetworkResourceRequest {
+  std::string url;
+};
+
+struct ReadStreamParams {
+  StreamID handle;
+  std::optional<unsigned long> size;
+  std::optional<unsigned long> offset;
+};
+
+struct NetworkResource {
+  bool success{};
+  std::optional<std::string> stream;
+  std::optional<int> httpStatusCode;
+  std::optional<std::string> netErrorName;
+  std::optional<Headers> headers;
+  folly::dynamic toDynamic() const {
+    auto dynamicResource = folly::dynamic::object("success", success);
+
+    if (success) { // stream IFF successful
+      assert(stream);
+      dynamicResource("stream", *stream);
+    }
+
+    if (netErrorName) { // Only if unsuccessful
+      assert(!success);
+      dynamicResource("netErrorName", *netErrorName);
+    }
+
+    if (httpStatusCode) { // Guaranteed if successful
+      dynamicResource("httpStatusCode", *httpStatusCode);
+    } else {
+      assert(!success);
+    }
+
+    if (headers) { // Guaranteed if successful
+      auto dynamicHeaders = folly::dynamic::object();
+      for (const auto& pair : *headers) {
+        dynamicHeaders(pair.first, pair.second);
+      }
+      dynamicResource("headers", std::move(dynamicHeaders));
+    } else {
+      assert(!success);
+    }
+    return dynamicResource;
+  }
+};
+
+struct IOReadResult {
+  std::string data;
+  bool eof;
+  bool base64Encoded;
+  folly::dynamic toDynamic() const {
+    auto obj = folly::dynamic::object("data", data);
+    obj("eof", eof);
+    obj("base64Encoded", base64Encoded);
+    return obj;
+  }
+};
+
+/**
+ * Passed to `loadNetworkResource`, provides callbacks for processing incoming
+ * data and other events.
+ */
+class NetworkRequestListener {
+ public:
+  NetworkRequestListener() = default;
+  NetworkRequestListener(const NetworkRequestListener&) = delete;
+  NetworkRequestListener& operator=(const NetworkRequestListener&) = delete;
+  NetworkRequestListener(NetworkRequestListener&&) noexcept = default;
+  NetworkRequestListener& operator=(NetworkRequestListener&&) noexcept =
+      default;
+  virtual ~NetworkRequestListener() = default;
+
+  /**
+   * To be called by the delegate on receipt of response headers, including
+   * on "unsuccessful" status codes.
+   *
+   * \param httpStatusCode The HTTP status code received.
+   * \param headers Response headers as an unordered_map.
+   */
+  virtual void onHeaders(int httpStatusCode, const Headers& headers) = 0;
+
+  /**
+   * To be called by the delegate on receipt of data chunks.
+   * \param data The data received.
+   */
+  virtual void onData(std::string_view data) = 0;
+
+  /**
+   * To be called by the delegate on any error with the request, either before
+   * headers are received or for a subsequent interrupion.
+   *
+   * \param message A short, human-readable message, which may be forwarded to
+   * the CDP client either in the `loadNetworkResource` response (if headers
+   * were not yet received), or as a CDP error in response to a subsequent
+   * `IO.read`.
+   */
+  virtual void onError(const std::string& message) = 0;
+
+  /**
+   * To be called by the delegate on successful completion of the request.
+   * Delegates must call *either* onCompletion() or onError() exactly once.
+   */
+  virtual void onCompletion() = 0;
+
+  /**
+   * Optionally (preferably) used to give NetworkIOAgent
+    a way to cancel an
+   * in-progress download.
+   *
+   * \param cancelFunction A function that can be called to cancel a download,
+   * may be called before or after the download is complete.
+   */
+  virtual void setCancelFunction(std::function<void()> cancelFunction) = 0;
+};
+
+/**
+ * Implemented by the HostTargetDelegate per-platform to perform network
+ * requests.
+ */
+class LoadNetworkResourceDelegate {
+ public:
+  LoadNetworkResourceDelegate() = default;
+  LoadNetworkResourceDelegate(const LoadNetworkResourceDelegate&) = delete;
+  LoadNetworkResourceDelegate& operator=(const LoadNetworkResourceDelegate&) =
+      delete;
+  LoadNetworkResourceDelegate(LoadNetworkResourceDelegate&&) noexcept = delete;
+  LoadNetworkResourceDelegate& operator=(
+      LoadNetworkResourceDelegate&&) noexcept = delete;
+  virtual ~LoadNetworkResourceDelegate() = default;
+
+  /**
+   * Called by NetworkIOAgent on handling a
+   * `Network.loadNetworkResource` CDP request. Platform implementations should
+   * override this to perform a network request of the given URL, and use
+   * listener's callbacks (via the executor) on receipt of headers, data chunks,
+   * and errors.
+   *
+   * \param params A LoadNetworkResourceRequest, including the url.
+   * \param executor A listener-scoped executor used by the delegate to execute
+   * listener callbacks on headers, data chunks, and errors. Implementations
+   * *should* call listener->setCancelFunction() to provide a lambda that can be
+   * called to abort any in-flight network operation that is no longer needed.
+   */
+  virtual void loadNetworkResource(
+      [[maybe_unused]] const LoadNetworkResourceRequest& params,
+      [[maybe_unused]] ScopedExecutor<NetworkRequestListener> executor) = 0;
+};
+
+/**
+ * Provides an agent for handling CDP's Network.loadNetworkResource, IO.read and
+ * IO.close.
+ *
+ * Owns state of all in-progress and completed HTTP requests - ensure
+ * IO.close is used to free resources once consumed.
+ *
+ * Public methods must be called the same thread as the given executor.
+ */
+class NetworkIOAgent {
+ public:
+  /**
+   * \param frontendChannel A channel used to send responses to the
+   * frontend.
+   * \param executor An executor used for any callbacks provided, and for
+   * processing incoming data or other events from network operations.
+   */
+  NetworkIOAgent(FrontendChannel frontendChannel, VoidExecutor executor)
+      : frontendChannel_(frontendChannel),
+        executor_(executor),
+        streams_(std::make_shared<StreamsMap>()) {}
+
+  /**
+   * Handle a CDP request. The response will be sent over the provided
+   * \c FrontendChannel synchronously or asynchronously.
+   * \param req The parsed request.
+   */
+  bool handleRequest(
+      const cdp::PreparsedRequest& req,
+      LoadNetworkResourceDelegate& delegate);
+
+ private:
+  /**
+   * A channel used to send responses and events to the frontend.
+   */
+  FrontendChannel frontendChannel_;
+
+  /**
+   * An executor used to create NetworkRequestListener-scoped executors for the
+   * delegate.
+   */
+  VoidExecutor executor_;
+
+  /**
+   * Map of stream objects, which contain data received, accept read requests
+   * and listen for delegate events. Delegates have a scoped executor for Stream
+   * instances, but Streams will not live beyond the destruction of this
+   * NetworkIOAgent instance + executor scope.
+   *
+   * This is a shared_ptr so that we may capture a weak_ptr in our
+   * Stream::create callback without creating a cycle.
+   */
+  std::shared_ptr<StreamsMap> streams_;
+
+  /**
+   * Stream IDs are strings of an incrementing integer, unique within each
+   * NewtworkIOAgent instance. This stores the next one to use.
+   */
+  unsigned long nextStreamId_{0};
+
+  /**
+   * Begin loading an HTTP resource, delegating platform-specific
+   * implementation, responding to the frontend on headers received or on error.
+   * Does not catch exceptions thrown by the delegate (such as
+   * NotImplementedException).
+   */
+  void handleLoadNetworkResource(
+      const cdp::PreparsedRequest& req,
+      LoadNetworkResourceDelegate& delegate);
+
+  /**
+   * Handle an IO.read CDP request. Emit a chunk of data from the stream, once
+   * enough has been downloaded, or report an error.
+   */
+  void handleIoRead(const cdp::PreparsedRequest& req);
+
+  /**
+   * Handle an IO.close CDP request. Safely aborts any in-flight request.
+   * Reports CDP ok if the stream is found, or a CDP error if not.
+   */
+  void handleIoClose(const cdp::PreparsedRequest& req);
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/TEMP_UntilReactCommonUpdate/jsinspector-modern/Utf8.h

@@ -0,0 +1,56 @@
+/*
+ * 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 <vector>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Takes a vector of bytes representing a fragment of a UTF-8 string, and
+ * removes the minimum number (0-3) of trailing bytes so that the remainder is
+ * valid UTF-8. Useful for slicing binary data into UTF-8 strings.
+ *
+ * \param buffer Buffer to operate on - will be resized if necessary.
+ */
+inline void truncateToValidUTF8(std::vector<char>& buffer) {
+  const auto length = buffer.size();
+  // Ensure we don't cut a UTF-8 code point in the middle by removing any
+  // trailing bytes representing an incomplete UTF-8 code point.
+
+  // If the last byte is a UTF-8 first byte or continuation byte (topmost bit
+  // is 1) (otherwise the last char is ASCII and we don't need to do
+  // anything).
+  if (length > 0 && (buffer[length - 1] & 0b10000000) == 0b10000000) {
+    size_t continuationBytes = 0; // [Windows #13587]
+    // Find the first byte of the UTF-8 code point (topmost bits 11) and count
+    // the number of continuation bytes following it.
+    while ((buffer[length - continuationBytes - 1] & 0b11000000) !=
+           0b11000000) {
+      continuationBytes++;
+      if (continuationBytes > 3 || continuationBytes >= length - 1) {
+        throw std::runtime_error("Invalid UTF-8 sequence");
+      }
+    }
+    char firstByteOfSequence = buffer[length - continuationBytes - 1];
+    // Check for the special case that our original cut point was at the end
+    // of a UTF-8 code-point, and therefore already valid. This will be the
+    // case if the first byte indicates continuationBytes continuation bytes
+    // should follow, i.e. its top bits are (1+continuationBytes) 1's followed
+    // by a 0.
+    char mask = static_cast<char>(0b11111000 << (3 - continuationBytes));
+    char expectedBitsAfterMask = static_cast<char>(mask << 1);
+    if (continuationBytes == 0 ||
+        (firstByteOfSequence & mask) != expectedBitsAfterMask) {
+      // Remove the trailing continuation bytes, if any, and the first byte.
+      buffer.resize(length - (continuationBytes + 1));
+    }
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/Base.h

@@ -5,10 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+ // [Windows #13391]
+
 #pragma once
 
 #include <jsi/jsi.h>
-#include <Convert.h> // [Windows]
+#include <Convert.h>
 
 #include <cstdint>
 #include <memory>

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/Bridging.h

@@ -13,9 +13,9 @@
 #include <react/bridging/Class.h>
 // #include <react/bridging/Dynamic.h> // Line causes Error C1083 Cannot open include file: 'double-conversion/double-conversion.h' #11644
 #include <react/bridging/Error.h>
-#include <react/bridging/EventEmitter.h>
+#include <react/bridging/EventEmitter.h> // [Windows #13391]
 #include <react/bridging/Function.h>
 #include <react/bridging/Number.h>
 #include <react/bridging/Object.h>
 #include <react/bridging/Promise.h>
-#include <react/bridging/Value.h>
+#include <react/bridging/Value.h> // [Windows #13391]

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/CallbackWrapper.h

@@ -11,7 +11,7 @@
 
 #include <memory>
 
-#include <LongLivedObject.h> // [Windows]
+#include <LongLivedObject.h> // [Windows #13391]
 
 namespace facebook::react {
 

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/Convert.h

@@ -0,0 +1,172 @@
+/*
+ * 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.
+ */
+
+ // [Windows #13391]
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <optional>
+#include <type_traits>
+
+namespace facebook::react::bridging {
+
+// std::remove_cvref_t is not available until C++20.
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+template <typename T>
+inline constexpr bool is_jsi_v =
+    std::is_same_v<jsi::Value, remove_cvref_t<T>> ||
+    std::is_same_v<jsi::String, remove_cvref_t<T>> ||
+    std::is_base_of_v<jsi::Object, remove_cvref_t<T>>;
+
+template <typename>
+struct is_optional : std::false_type {};
+
+template <typename T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_optional_v = is_optional<T>::value;
+
+template <typename T, typename = void>
+inline constexpr bool is_optional_jsi_v = false;
+
+template <typename T>
+inline constexpr bool
+    is_optional_jsi_v<T, typename std::enable_if_t<is_optional_v<T>>> =
+        is_jsi_v<typename T::value_type>;
+
+template <typename T>
+struct Converter;
+
+template <typename T>
+struct ConverterBase {
+  using BaseT = remove_cvref_t<T>;
+
+  ConverterBase(jsi::Runtime& rt, T&& value)
+      : rt_(rt), value_(std::forward<T>(value)) {}
+
+  operator BaseT() && {
+    if constexpr (std::is_lvalue_reference_v<T>) {
+      // Copy the reference into a Value that then can be moved from.
+      auto value = jsi::Value(rt_, value_);
+
+      if constexpr (std::is_same_v<BaseT, jsi::Value>) {
+        return std::move(value);
+      } else if constexpr (std::is_same_v<BaseT, jsi::String>) {
+        return std::move(value).getString(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Object>) {
+        return std::move(value).getObject(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Array>) {
+        return std::move(value).getObject(rt_).getArray(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::Function>) {
+        return std::move(value).getObject(rt_).getFunction(rt_);
+      }
+    } else {
+      return std::move(value_);
+    }
+  }
+
+  template <
+      typename U,
+      std::enable_if_t<
+          std::is_lvalue_reference_v<T> &&
+              // Ensure non-reference type can be converted to the desired type.
+              std::is_convertible_v<Converter<BaseT>, U>,
+          int> = 0>
+  operator U() && {
+    return Converter<BaseT>(rt_, std::move(*this).operator BaseT());
+  }
+
+  template <
+      typename U,
+      std::enable_if_t<is_jsi_v<T> && std::is_same_v<U, jsi::Value>, int> = 0>
+  operator U() && = delete; // Prevent unwanted upcasting of JSI values.
+
+ protected:
+  jsi::Runtime& rt_;
+  T value_;
+};
+
+template <typename T>
+struct Converter : public ConverterBase<T> {
+  using ConverterBase<T>::ConverterBase;
+};
+
+template <>
+struct Converter<jsi::Value> : public ConverterBase<jsi::Value> {
+  using ConverterBase<jsi::Value>::ConverterBase;
+
+  operator jsi::String() && {
+    return std::move(value_).asString(rt_);
+  }
+
+  operator jsi::Object() && {
+    return std::move(value_).asObject(rt_);
+  }
+
+  operator jsi::Array() && {
+    return std::move(value_).asObject(rt_).asArray(rt_);
+  }
+
+  operator jsi::Function() && {
+    return std::move(value_).asObject(rt_).asFunction(rt_);
+  }
+};
+
+template <>
+struct Converter<jsi::Object> : public ConverterBase<jsi::Object> {
+  using ConverterBase<jsi::Object>::ConverterBase;
+
+  operator jsi::Array() && {
+    return std::move(value_).asArray(rt_);
+  }
+
+  operator jsi::Function() && {
+    return std::move(value_).asFunction(rt_);
+  }
+};
+
+template <typename T>
+struct Converter<std::optional<T>> : public ConverterBase<jsi::Value> {
+  Converter(jsi::Runtime& rt, std::optional<T> value)
+      : ConverterBase(rt, value ? std::move(*value) : jsi::Value::null()) {}
+
+  operator std::optional<T>() && {
+    if (value_.isNull() || value_.isUndefined()) {
+      return {};
+    }
+    return std::move(value_);
+  }
+};
+
+template <typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
+auto convert(jsi::Runtime& rt, T&& value) {
+  return Converter<T>(rt, std::forward<T>(value));
+}
+
+template <
+    typename T,
+    std::enable_if_t<is_jsi_v<T> || std::is_scalar_v<T>, int> = 0>
+auto convert(jsi::Runtime& rt, std::optional<T> value) {
+  return Converter<std::optional<T>>(rt, std::move(value));
+}
+
+template <typename T, std::enable_if_t<std::is_scalar_v<T>, int> = 0>
+auto convert(jsi::Runtime& rt, T&& value) {
+  return value;
+}
+
+template <typename T>
+auto convert(jsi::Runtime& rt, Converter<T>&& converter) {
+  return std::move(converter);
+}
+
+} // namespace facebook::react::bridging

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/EventEmitter.h

@@ -5,9 +5,11 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+ // [Windows #13391]
+
 #pragma once
 
-#include <Function.h> // [Windows]
+#include <Function.h> // [Windows #13391]
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -104,10 +106,7 @@ class AsyncEventEmitter : public IAsyncEventEmitter {
   jsi::Object get(
       jsi::Runtime& rt,
       const std::shared_ptr<CallInvoker>& jsInvoker) const override {
-    auto result = jsi::Object(rt);
-    result.setProperty(
-        rt, "addListener", bridging::toJs(rt, listen_, jsInvoker));
-    return result;
+    return bridging::toJs(rt, listen_, jsInvoker);
   }
 
  private:

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/Function.h

@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include <Base.h> // [Windows]
-#include <CallbackWrapper.h> // [Windows]
+#include <Base.h> // [Windows #13391]
+#include <CallbackWrapper.h> // [Windows #13391]
 
 #include <ReactCommon/CallInvoker.h>
 #include <ReactCommon/SchedulerPriority.h>

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModule.h

@@ -14,7 +14,7 @@
 #include <jsi/jsi.h>
 
 #include <ReactCommon/CallInvoker.h>
-#include <EventEmitter.h> // [Windows]
+#include <EventEmitter.h> // [Windows #13391]
 
 namespace facebook::react {
 

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModuleUtils.h

@@ -11,8 +11,9 @@
 #include <string>
 
 #include <jsi/jsi.h>
-#include <CallbackWrapper.h> // [Windows]
-#include <LongLivedObject.h> // [Windows]
+#include <LongLivedObject.h> // [Windows #13391]
+
+#include <CallbackWrapper.h> // [Windows #13391]
 
 namespace facebook::react {
 

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/scrollview/ScrollViewProps.cpp

@@ -91,6 +91,15 @@ ScrollViewProps::ScrollViewProps(
                     "automaticallyAdjustsScrollIndicatorInsets",
                     sourceProps.automaticallyAdjustsScrollIndicatorInsets,
                     true)),
+      automaticallyAdjustKeyboardInsets(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.automaticallyAdjustKeyboardInsets
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "automaticallyAdjustKeyboardInsets",
+                    sourceProps.automaticallyAdjustKeyboardInsets,
+                    false)),
       decelerationRate(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.decelerationRate