react-native-windows 0.70.8 → 0.71.0-preview.1

package/.flowconfig

@@ -51,7 +51,7 @@
 <PROJECT_ROOT>/template/.*
 
 ; Ignore the Dangerfile
-<PROJECT_ROOT>/bots/dangerfile.js
+<PROJECT_ROOT>/packages/react-native-bots/dangerfile.js
 
 ; Ignore "BUCK" generated dirs
 <PROJECT_ROOT>/\.buckd/
@@ -67,7 +67,6 @@
 [include]
 ; Need to include hoisted modules
 ../node_modules/
-../packages/@react-native-windows/virtualized-list/
 
 [libs]
 interface.js
@@ -77,7 +76,6 @@ flow/
 emoji=true
 
 exact_by_default=true
-exact_empty_objects=true
 
 format.bracket_spacing=false
 
@@ -89,7 +87,6 @@ munge_underscores=true
 
 module.name_mapper='^react-native$' -> '<PROJECT_ROOT>/index.windows.js'
 module.name_mapper='^react-native-windows$' -> '<PROJECT_ROOT>/index.windows.js'
-module.name_mapper='^@react-native-windows/virtualized-list$' -> '<PROJECT_ROOT>/../packages/@react-native-windows/virtualized-list/src/VirtualizedList.js'
 module.name_mapper='^react-native/\(.*\)$' -> '<PROJECT_ROOT>/\1'
 module.name_mapper='^react-native-windows/\(.*\)$' -> '<PROJECT_ROOT>/\1'
 module.name_mapper='^@?[./a-zA-Z0-9$_-]+\.\(bmp\|gif\|jpg\|jpeg\|png\|psd\|svg\|webp\|m4v\|mov\|mp4\|mpeg\|mpg\|webm\|aac\|aiff\|caf\|m4a\|mp3\|wav\|html\|pdf\)$' -> '<PROJECT_ROOT>/Libraries/Image/RelativeImageStub'
@@ -100,7 +97,7 @@ suppress_type=$FlowFixMeProps
 suppress_type=$FlowFixMeState
 suppress_type=$FlowFixMeEmpty
 
-experimental.env_mode=ssa
+inference_mode=constrain_writes
 
 [lints]
 sketchy-null-number=warn
@@ -122,4 +119,4 @@ untyped-import
 untyped-type-import
 
 [version]
-^0.182.0
+^0.191.0

package/Directory.Build.props

@@ -16,8 +16,8 @@
     -->
     <EnableSourceLink Condition="'$(EnableSourceLink)' == ''">false</EnableSourceLink>
     <!-- When bumping the Folly version, be sure to bump the git hash of that version's commit and build Folly.vcxproj (to update its cgmanifest.json) too. -->
-    <FollyVersion>2021.07.22.00</FollyVersion>
-    <FollyCommitHash>4baba28200d7446c870e96f3cdbeb492f54625d0</FollyCommitHash>
+    <FollyVersion>2022.11.07.00</FollyVersion>
+    <FollyCommitHash>2aa28128d1f7a04b41521367f0b615f782814089</FollyCommitHash>
     <!-- When bumping the fmt version, be sure to bump the git hash of that version's commit and build fmt.vcxproj (to update its cgmanifest.json) too. -->
     <FmtVersion>8.0.0</FmtVersion>
     <FmtCommitHash>9e8b86fd2d9806672cc73133d21780dd182bfd24</FmtCommitHash>

package/Folly/Folly.vcxproj

@@ -51,10 +51,10 @@
     <ClCompile Include="$(FollyDir)\folly\portability\Unistd.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="$(FollyDir)\folly\system\AtFork.cpp" />
     <ClCompile Include="$(FollyDir)\folly\system\ThreadId.cpp" />
     <ClCompile Include="$(FollyDir)\folly\lang\SafeAssert.cpp" />
     <ClCompile Include="$(FollyDir)\folly\lang\ToAscii.cpp" />
-    <ClCompile Include="$(FollyDir)\folly\lang\Assume.cpp" />
     <ClCompile Include="$(FollyDir)\folly\json_pointer.cpp" />
     <ClCompile Include="$(FollyDir)\folly\Format.cpp" />
     <ClCompile Include="$(FollyDir)\folly\String.cpp" />
@@ -143,6 +143,7 @@
     <ClInclude Include="$(FollyDir)\folly\IPAddressV4.h" />
     <ClInclude Include="$(FollyDir)\folly\IPAddressV6.h" />
     <ClInclude Include="$(FollyDir)\folly\json.h" />
+    <ClInclude Include="$(FollyDir)\folly\lang\ToAscii.h" />
     <ClInclude Include="$(FollyDir)\folly\Lazy.h" />
     <ClInclude Include="$(FollyDir)\folly\Likely.h" />
     <ClInclude Include="$(FollyDir)\folly\LockTraits.h" />
@@ -291,6 +292,7 @@
   <Target Name="WriteCGManifest" BeforeTargets="PrepareForBuild" DependsOnTargets="DownloadFolly" Inputs="$(FollyZipFile)" Outputs="$(CGManifestFile)">
     <PropertyGroup>
       <CGManifestText>{
+    "$schema": "https://json.schemastore.org/component-detection-manifest.json",
     "Registrations": [
         {
             "Component": {
@@ -319,7 +321,7 @@
   </ItemGroup>
   <Target Name="Deploy" />
   <!-- Reenable this task if we need to temporarily replace any folly files for fixes, while we wait for PRs to land in folly -->
-  <Target Name="ApplyFollyTemporaryPatch" BeforeTargets="PrepareForBuild" DependsOnTargets="UnzipFolly" Inputs="@(TemporaryFollyPatchFiles)" Outputs="@(TemporaryFollyPatchFiles->'$(FollyDir)folly\%(RecursiveDir)%(Filename)%(Extension)')">
+  <Target Name="ApplyFollyTemporaryPatch" BeforeTargets="PrepareForBuild" DependsOnTargets="UnzipFolly">
     <Message Importance="High" Text="Applying temporary patches to folly." />
     <Copy DestinationFiles="@(TemporaryFollyPatchFiles->'$(FollyDir)folly\%(RecursiveDir)%(Filename)%(Extension)')" SourceFiles="@(TemporaryFollyPatchFiles)" />
   </Target>

package/Folly/Folly.vcxproj.filters

@@ -28,6 +28,9 @@
     <Filter Include="Source Files\portability">
       <UniqueIdentifier>{9ad1fbe7-56fb-40d8-b0a2-ac0d6d0799e3}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files\lang">
+      <UniqueIdentifier>{ed8c80f6-ff7c-4f61-b7ec-a2aee564d575}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="$(FollyDir)\folly\system\ThreadId.cpp">
@@ -39,9 +42,6 @@
     <ClCompile Include="$(FollyDir)\folly\lang\ToAscii.cpp">
       <Filter>Source Files\lang</Filter>
     </ClCompile>
-    <ClCompile Include="$(FollyDir)\folly\lang\Assume.cpp">
-      <Filter>Source Files\lang</Filter>
-    </ClCompile>
     <ClCompile Include="$(FollyDir)\folly\Conv.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -82,6 +82,7 @@
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="pch.cpp" />
+    <ClCompile Include="$(FollyDir)\folly\system\AtFork.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="$(FollyDir)\folly\portability\Asm.h">
@@ -535,6 +536,9 @@
       <Filter>Header Files\detail</Filter>
     </ClInclude>
     <ClInclude Include="pch.h" />
+    <ClInclude Include="$(FollyDir)\folly\lang\ToAscii.h">
+      <Filter>Header Files\lang</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Natvis Include="Folly.natvis" />

package/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
 #include <folly/Conv.h>
 #include <folly/Format.h>
 #include <folly/Likely.h>
+#include <folly/Portability.h>
 #include <folly/detail/Iterators.h>
 #include <folly/lang/Exception.h>
 
@@ -87,38 +88,41 @@ struct hash<::folly::dynamic> {
 } // namespace std
 
 //////////////////////////////////////////////////////////////////////
-
+/* clang-format off */
 // This is a higher-order preprocessor macro to aid going from runtime
 // types to the compile time type system.
-#define FB_DYNAMIC_APPLY(type, apply) \
-  do {                                \
-    switch ((type)) {                 \
-      case NULLT:                     \
-        apply(std::nullptr_t);        \
-        break;                        \
-      case ARRAY:                     \
-        apply(Array);                 \
-        break;                        \
-      case BOOL:                      \
-        apply(bool);                  \
-        break;                        \
-      case DOUBLE:                    \
-        apply(double);                \
-        break;                        \
-      case INT64:                     \
-        apply(int64_t);               \
-        break;                        \
-      case OBJECT:                    \
-        apply(ObjectImpl);            \
-        break;                        \
-      case STRING:                    \
-        apply(std::string);           \
-        break;                        \
-      default:                        \
-        abort();                      \
-    }                                 \
-  } while (0)
 
+#define FB_DYNAMIC_APPLY(type, apply)                                             \
+  do {                                                                            \
+    FOLLY_PUSH_WARNING FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")    \
+    switch ((type)) {                                                             \
+      case NULLT:                                                                 \
+        apply(std::nullptr_t);                                                    \
+        break;                                                                    \
+      case ARRAY:                                                                 \
+        apply(Array);                                                             \
+        break;                                                                    \
+      case BOOL:                                                                  \
+        apply(bool);                                                              \
+        break;                                                                    \
+      case DOUBLE:                                                                \
+        apply(double);                                                            \
+        break;                                                                    \
+      case INT64:                                                                 \
+        apply(int64_t);                                                           \
+        break;                                                                    \
+      case OBJECT:                                                                \
+        apply(ObjectImpl);                                                        \
+        break;                                                                    \
+      case STRING:                                                                \
+        apply(std::string);                                                       \
+        break;                                                                    \
+      default:                                                                    \
+        abort();                                                                  \
+    }                                                                             \
+    FOLLY_POP_WARNING                                                             \
+  } while (0)
+/* clang-format on */
 //////////////////////////////////////////////////////////////////////
 
 namespace folly {
@@ -235,6 +239,7 @@ struct dynamic::item_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::iterator,
       std::pair<dynamic const, dynamic>,
       std::forward_iterator_tag>;
+  item_iterator() = default;
   /* implicit */ item_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
 
   using object_type = dynamic::ObjectImpl;
@@ -250,6 +255,7 @@ struct dynamic::value_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::iterator,
       dynamic,
       std::forward_iterator_tag>;
+  value_iterator() = default;
   /* implicit */ value_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
 
   using object_type = dynamic::ObjectImpl;
@@ -268,6 +274,7 @@ struct dynamic::const_item_iterator
       dynamic::ObjectImpl::const_iterator,
       std::pair<dynamic const, dynamic> const,
       std::forward_iterator_tag>;
+  const_item_iterator() = default;
   /* implicit */ const_item_iterator(dynamic::ObjectImpl::const_iterator b)
       : Super(b) {}
   /* implicit */ const_item_iterator(const_item_iterator const& i)
@@ -287,6 +294,7 @@ struct dynamic::const_key_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::const_iterator,
       dynamic const,
       std::forward_iterator_tag>;
+  const_key_iterator() = default;
   /* implicit */ const_key_iterator(dynamic::ObjectImpl::const_iterator b)
       : Super(b) {}
 
@@ -305,6 +313,7 @@ struct dynamic::const_value_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::const_iterator,
       dynamic const,
       std::forward_iterator_tag>;
+  const_value_iterator() = default;
   /* implicit */ const_value_iterator(dynamic::ObjectImpl::const_iterator b)
       : Super(b) {}
   /* implicit */ const_value_iterator(value_iterator i) : Super(i.base()) {}
@@ -348,14 +357,6 @@ inline dynamic::dynamic(ObjectMaker&& maker) : type_(OBJECT) {
       ObjectImpl(std::move(*maker.val_.getAddress<ObjectImpl>()));
 }
 
-inline dynamic::dynamic(dynamic const& o) : type_(NULLT) {
-  *this = o;
-}
-
-inline dynamic::dynamic(dynamic&& o) noexcept : type_(NULLT) {
-  *this = std::move(o);
-}
-
 inline dynamic::~dynamic() noexcept {
   destroy();
 }
@@ -558,7 +559,7 @@ struct dynamic::CompareOp<dynamic::ObjectImpl> {
 template <>
 struct dynamic::CompareOp<std::nullptr_t> {
   static bool comp(std::nullptr_t const&, std::nullptr_t const&) {
-    return true;
+    return false;
   }
 };
 
@@ -834,6 +835,20 @@ inline dynamic::IfNotIterator<K, void> dynamic::insert(K&& key, V&& val) {
   obj[std::forward<K>(key)] = std::forward<V>(val);
 }
 
+template <class... Args>
+inline std::pair<dynamic::item_iterator, bool> dynamic::emplace(
+    Args&&... args) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(std::forward<Args>(args)...);
+}
+
+template <class K, class... Args>
+inline std::pair<dynamic::item_iterator, bool> dynamic::try_emplace(
+    K&& key, Args&&... args) {
+  auto& obj = get<ObjectImpl>();
+  return obj.try_emplace(std::forward<K>(key), std::forward<Args>(args)...);
+}
+
 template <class T>
 inline dynamic::iterator dynamic::insert(const_iterator pos, T&& value) {
   auto& arr = get<Array>();
@@ -993,6 +1008,8 @@ FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::ObjectImpl, dynamic::OBJECT)
 
 template <class T>
 T dynamic::asImpl() const {
+  FOLLY_PUSH_WARNING
+  FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")
   switch (type()) {
     case INT64:
       return to<T>(*get_nothrow<int64_t>());
@@ -1008,10 +1025,10 @@ T dynamic::asImpl() const {
     default:
       throw_exception<TypeError>("int/double/bool/string", type());
   }
+  FOLLY_POP_WARNING
 }
 
 // Return a T* to our type, or null if we're not that type.
-// clang-format off
 template <class T>
 T* dynamic::get_nothrow() & noexcept {
   if (type_ != TypeInfo<T>::type) {
@@ -1019,7 +1036,6 @@ T* dynamic::get_nothrow() & noexcept {
   }
   return getAddress<T>();
 }
-// clang-format on
 
 template <class T>
 T const* dynamic::get_nothrow() const& noexcept {
@@ -1216,7 +1232,7 @@ const_dynamic_view::descend_unchecked_(Key const& key) const noexcept {
     if /* constexpr */ (!std::is_integral<Key>::value) {
       return nullptr;
     }
-    if (key < 0 || key >= parray->size()) {
+    if (key < 0 || folly::to_unsigned(key) >= parray->size()) {
       return nullptr;
     }
     return &(*parray)[size_t(key)];
@@ -1327,7 +1343,7 @@ inline std::string dynamic_view::move_string_or(Stringish&& val) {
 
 //////////////////////////////////////////////////////////////////////
 
-// Secialization of FormatValue so dynamic objects can be formatted
+// Specialization of FormatValue so dynamic objects can be formatted
 template <>
 class FormatValue<dynamic> {
  public:

package/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <utility>
+
+#include <folly/CppAttributes.h>
+#include <folly/Portability.h>
+#include <folly/Preprocessor.h>
+#include <folly/lang/CArray.h>
+
+#define FOLLY_DETAIL_SAFE_CHECK_IMPL(d, p, u, expr, ...)                  \
+  do {                                                                    \
+    if ((!d || ::folly::kIsDebug || ::folly::kIsSanitize) &&              \
+        !static_cast<bool>(expr)) {                                       \
+      static constexpr auto __folly_detail_safe_assert_fun = __func__;    \
+      static constexpr ::folly::detail::safe_assert_arg                   \
+          __folly_detail_safe_assert_arg{                                 \
+              u ? nullptr : #expr,                                        \
+              __FILE__,                                                   \
+              FOLLY_PP_CONSTINIT_LINE_UNSIGNED,                           \
+              __folly_detail_safe_assert_fun,                             \
+              ::folly::detail::safe_assert_msg_types<                     \
+                  decltype(::folly::detail::safe_assert_msg_types_seq_of( \
+                      __VA_ARGS__))>::value.data};                        \
+      constexpr ::folly::detail::safe_assert_terminate_w<p>               \
+          __folly_detail_safe_assert_terminate_w{                         \
+              __folly_detail_safe_assert_arg};                            \
+      __folly_detail_safe_assert_terminate_w(__VA_ARGS__);                \
+    }                                                                     \
+  } while (false)
+
+//  FOLLY_SAFE_CHECK
+//
+//  If expr evaluates to false after explicit conversion to bool, prints context
+//  information to stderr and aborts. Context information includes the remaining
+//  variadic arguments.
+//
+//  When the remaining variadic arguments are printed to stderr, there are two
+//  supported types after implicit conversions: char const* and uint64_t. This
+//  facility is intentionally not extensible to custom types.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_CHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_DCHECK
+//
+//  Equivalent to FOLLY_SAFE_CHECK when in debug or instrumented builds, where
+//  debug builds are signalled by NDEBUG being undefined and instrumented builds
+//  include sanitizer builds.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_PCHECK
+//
+//  Equivalent to FOLLY_SAFE_CHECK but includes errno in the contextual
+//  information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_PCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 1, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_DPCHECK
+//
+//  Equivalent to FOLLY_SAFE_DCHECK but includes errno in the contextual
+//  information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DPCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 1, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_FATAL
+//
+//  Equivalent to FOLLY_SAFE_CHECK(false, ...) but excludes any failing
+//  expression from the contextual information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_FATAL(...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 1, false, __VA_ARGS__)
+
+//  FOLLY_SAFE_DFATAL
+//
+//  Equivalent to FOLLY_SAFE_DCHECK(false, ...) but excludes any failing
+//  expression from the contextual information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DFATAL(...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 1, false, __VA_ARGS__)
+
+namespace folly {
+namespace detail {
+
+enum class safe_assert_msg_type : char { term, cstr, ui64 };
+
+template <safe_assert_msg_type... A>
+struct safe_assert_msg_type_s {};
+
+struct safe_assert_msg_types_one_fn {
+  template <safe_assert_msg_type A>
+  using c = std::integral_constant<safe_assert_msg_type, A>;
+  // only used in unevaluated contexts:
+  c<safe_assert_msg_type::cstr> operator()(char const*) const;
+  c<safe_assert_msg_type::ui64> operator()(uint64_t) const;
+};
+FOLLY_INLINE_VARIABLE constexpr safe_assert_msg_types_one_fn
+    safe_assert_msg_types_one{}; // a function object to prevent extensions
+
+template <typename... A>
+safe_assert_msg_type_s<decltype(safe_assert_msg_types_one((A)A{}))::value...>
+safe_assert_msg_types_seq_of(A...); // only used in unevaluated contexts
+
+template <typename>
+struct safe_assert_msg_types;
+template <safe_assert_msg_type... A>
+struct safe_assert_msg_types<safe_assert_msg_type_s<A...>> {
+  using value_type = c_array<safe_assert_msg_type, sizeof...(A) + 1>;
+  static constexpr value_type value = {{A..., safe_assert_msg_type::term}};
+};
+template <safe_assert_msg_type... A>
+constexpr
+    typename safe_assert_msg_types<safe_assert_msg_type_s<A...>>::value_type
+        safe_assert_msg_types<safe_assert_msg_type_s<A...>>::value;
+
+struct safe_assert_arg {
+  char const* expr;
+  char const* file;
+  unsigned int line;
+  char const* function;
+  safe_assert_msg_type const* msg_types;
+};
+
+struct safe_assert_msg_cast_one_fn {
+  FOLLY_ERASE auto operator()(char const* const a) const { return a; }
+  FOLLY_ERASE auto operator()(uint64_t const a) const { return a; }
+};
+FOLLY_INLINE_VARIABLE constexpr safe_assert_msg_cast_one_fn
+    safe_assert_msg_cast_one{}; // a function object to prevent extensions
+
+template <bool P>
+[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate(
+    safe_assert_arg const* arg, ...) noexcept; // the true backing function
+
+// [Win - Fixes Error C2908 explicit specialization; 'void folly::detail::safe_assert_terminate<false>(const folly::detail::safe_assert_arg *,...) noexcept' has already been instantiated 
+template <>
+[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate<0>(
+    safe_assert_arg const* arg, ...) noexcept;
+
+template <>
+[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate<1>(
+    safe_assert_arg const* arg, ...) noexcept;
+// Win]
+
+template <bool P>
+struct safe_assert_terminate_w {
+  safe_assert_arg const& arg;
+
+  FOLLY_ERASE constexpr safe_assert_terminate_w(
+      safe_assert_arg const& arg_) noexcept
+      : arg{arg_} {}
+
+  template <typename... A>
+  [[noreturn]] FOLLY_ERASE void operator()(A... a) const noexcept {
+    safe_assert_terminate<P>(&arg, safe_assert_msg_cast_one(a)...);
+  }
+};
+
+} // namespace detail
+} // namespace folly

package/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.cpp

@@ -189,7 +189,8 @@ FOLLY_ALWAYS_INLINE size_t to_ascii_size_clzll(uint64_t v) {
   }
 
   //  blog2r is approx 1 / log<2>(Base), used in log change-of-base just below
-  constexpr auto const blog2r = 8. / constexpr_log2(constexpr_pow(Base, 8));
+  constexpr auto const blog2m = constexpr_log2(constexpr_pow(Base, 8));
+  constexpr auto const blog2r = 8. / double(blog2m);
 
   //  vlogb is approx log<Base>(v) = log<2>(v) / log<2>(Base)
   auto const vlogb = vlog2 * size_t(blog2r * 256) / 256;
@@ -244,18 +245,19 @@ template <uint64_t Base, typename Alphabet>
 FOLLY_ALWAYS_INLINE void to_ascii_with_table(
     char* out, size_t size, uint64_t v) {
   using table = to_ascii_table<Base, Alphabet>;
-  auto pos = size - 2;
-  while (FOLLY_UNLIKELY(v >= Base * Base)) {
+  auto pos = size;
+  while (FOLLY_UNLIKELY(pos > 2)) {
+    pos -= 2;
     //  keep /, % together so a peephole optimization computes them together
     auto const q = v / (Base * Base);
     auto const r = v % (Base * Base);
     auto const val = table::data.data[size_t(r)];
     std::memcpy(out + pos, &val, 2);
-    pos -= 2;
     v = q;
   }
+
   auto const val = table::data.data[size_t(v)];
-  if (FOLLY_UNLIKELY(size % 2 == 0)) {
+  if (FOLLY_UNLIKELY(pos == 2)) {
     std::memcpy(out, &val, 2);
   } else {
     *out = val >> (kIsLittleEndian ? 8 : 0);

package/Folly/cgmanifest.json

@@ -1,11 +1,12 @@
 {
+    "$schema": "https://json.schemastore.org/component-detection-manifest.json",
     "Registrations": [
         {
             "Component": {
                 "Type": "git",
                 "Git": {
                   "RepositoryUrl": "https://github.com/facebook/folly",
-                  "CommitHash": "4baba28200d7446c870e96f3cdbeb492f54625d0"
+                  "CommitHash": "2aa28128d1f7a04b41521367f0b615f782814089"
                 }
             },
             "DevelopmentDependency": false

package/Libraries/ActionSheetIOS/ActionSheetIOS.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ *
+ * @format
+ */
+
+import {ProcessedColorValue} from '../StyleSheet/processColor';
+import {ColorValue} from '../StyleSheet/StyleSheet';
+
+/**
+ * @see: https://reactnative.dev/docs/actionsheetios#content
+ */
+export interface ActionSheetIOSOptions {
+  title?: string | undefined;
+  options: string[];
+  cancelButtonIndex?: number | undefined;
+  destructiveButtonIndex?: number | number[] | undefined | null;
+  message?: string | undefined;
+  anchor?: number | undefined;
+  tintColor?: ColorValue | ProcessedColorValue | undefined;
+  cancelButtonTintColor?: ColorValue | ProcessedColorValue | undefined;
+  userInterfaceStyle?: 'light' | 'dark' | undefined;
+  disabledButtonIndices?: number[] | undefined;
+}
+
+export interface ShareActionSheetIOSOptions {
+  message?: string | undefined;
+  url?: string | undefined;
+  subject?: string | undefined;
+  anchor?: number | undefined;
+  /** The activities to exclude from the ActionSheet.
+   * For example: ['com.apple.UIKit.activity.PostToTwitter']
+   */
+  excludedActivityTypes?: string[] | undefined;
+}
+
+/**
+ * @see https://reactnative.dev/docs/actionsheetios#content
+ */
+export interface ActionSheetIOSStatic {
+  /**
+   * Display an iOS action sheet. The `options` object must contain one or more
+   * of:
+   * - `options` (array of strings) - a list of button titles (required)
+   * - `cancelButtonIndex` (int) - index of cancel button in `options`
+   * - `destructiveButtonIndex` (int) - index of destructive button in `options`
+   * - `title` (string) - a title to show above the action sheet
+   * - `message` (string) - a message to show below the title
+   */
+  showActionSheetWithOptions: (
+    options: ActionSheetIOSOptions,
+    callback: (buttonIndex: number) => void,
+  ) => void;
+
+  /**
+   * Display the iOS share sheet. The `options` object should contain
+   * one or both of `message` and `url` and can additionally have
+   * a `subject` or `excludedActivityTypes`:
+   *
+   * - `url` (string) - a URL to share
+   * - `message` (string) - a message to share
+   * - `subject` (string) - a subject for the message
+   * - `excludedActivityTypes` (array) - the activities to exclude from the ActionSheet
+   *
+   * NOTE: if `url` points to a local file, or is a base64-encoded
+   * uri, the file it points to will be loaded and shared directly.
+   * In this way, you can share images, videos, PDF files, etc.
+   */
+  showShareActionSheetWithOptions: (
+    options: ShareActionSheetIOSOptions,
+    failureCallback: (error: Error) => void,
+    successCallback: (success: boolean, method: string) => void,
+  ) => void;
+}
+
+export const ActionSheetIOS: ActionSheetIOSStatic;
+export type ActionSheetIOS = ActionSheetIOSStatic;