react-native-windows 0.75.4 → 0.76.0-preview.2

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