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

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/mapbuffer/MapBufferBuilder.cpp

@@ -0,0 +1,182 @@
+/*
+ * 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.
+ */
+
+#include "MapBufferBuilder.h"
+#include <algorithm>
+
+using namespace facebook::react;
+
+namespace facebook {
+namespace react {
+
+constexpr uint32_t INT_SIZE = sizeof(uint32_t);
+constexpr uint32_t DOUBLE_SIZE = sizeof(double);
+constexpr uint32_t MAX_BUCKET_VALUE_SIZE = sizeof(uint64_t);
+
+MapBuffer MapBufferBuilder::EMPTY() {
+  return MapBufferBuilder(0).build();
+}
+
+MapBufferBuilder::MapBufferBuilder(uint32_t initialSize) {
+  buckets_.reserve(initialSize);
+  header_.count = 0;
+  header_.bufferSize = 0;
+}
+
+void MapBufferBuilder::storeKeyValue(
+    MapBuffer::Key key,
+    MapBuffer::DataType type,
+    uint8_t const *value,
+    uint32_t valueSize) {
+  if (valueSize > MAX_BUCKET_VALUE_SIZE) {
+    LOG(ERROR) << "Error: size of value must be <= MAX_VALUE_SIZE. ValueSize: "
+               << valueSize;
+    abort();
+  }
+
+  uint64_t data = 0;
+  auto *dataPtr = reinterpret_cast<uint8_t *>(&data);
+  memcpy(dataPtr, value, valueSize);
+
+  buckets_.emplace_back(key, static_cast<uint16_t>(type), data);
+
+  header_.count++;
+
+  if (lastKey_ > key) {
+    needsSort_ = true;
+  }
+  lastKey_ = key;
+}
+
+void MapBufferBuilder::putBool(MapBuffer::Key key, bool value) {
+  int intValue = (int)value;
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Boolean,
+      reinterpret_cast<uint8_t const *>(&intValue),
+      INT_SIZE);
+}
+
+void MapBufferBuilder::putDouble(MapBuffer::Key key, double value) {
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Double,
+      reinterpret_cast<uint8_t const *>(&value),
+      DOUBLE_SIZE);
+}
+
+void MapBufferBuilder::putInt(MapBuffer::Key key, int32_t value) {
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Int,
+      reinterpret_cast<uint8_t const *>(&value),
+      INT_SIZE);
+}
+
+void MapBufferBuilder::putString(MapBuffer::Key key, std::string const &value) {
+  auto strSize = value.size();
+  const char *strData = value.data();
+
+  // format [length of string (int)] + [Array of Characters in the string]
+  auto offset = dynamicData_.size();
+  dynamicData_.resize(offset + INT_SIZE + strSize, 0);
+  memcpy(dynamicData_.data() + offset, &strSize, INT_SIZE);
+  memcpy(dynamicData_.data() + offset + INT_SIZE, strData, strSize);
+
+  // Store Key and pointer to the string
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::String,
+      reinterpret_cast<uint8_t const *>(&offset),
+      INT_SIZE);
+}
+
+void MapBufferBuilder::putMapBuffer(MapBuffer::Key key, MapBuffer const &map) {
+  auto mapBufferSize = map.size();
+
+  auto offset = dynamicData_.size();
+
+  // format [length of buffer (int)] + [bytes of MapBuffer]
+  dynamicData_.resize(offset + INT_SIZE + mapBufferSize, 0);
+  memcpy(dynamicData_.data() + offset, &mapBufferSize, INT_SIZE);
+  // Copy the content of the map into dynamicData_
+  memcpy(dynamicData_.data() + offset + INT_SIZE, map.data(), mapBufferSize);
+
+  // Store Key and pointer to the string
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Map,
+      reinterpret_cast<uint8_t const *>(&offset),
+      INT_SIZE);
+}
+
+void MapBufferBuilder::putMapBufferList(
+    MapBuffer::Key key,
+    const std::vector<MapBuffer> &mapBufferList) {
+  auto offset = dynamicData_.size();
+  size_t dataSize = 0;
+  for (const MapBuffer &mapBuffer : mapBufferList) {
+    dataSize = dataSize + INT_SIZE + mapBuffer.size();
+  }
+
+  dynamicData_.resize(offset + INT_SIZE, 0);
+  memcpy(dynamicData_.data() + offset, &dataSize, INT_SIZE);
+
+  for (const MapBuffer &mapBuffer : mapBufferList) {
+    auto mapBufferSize = mapBuffer.size();
+    auto dynamicDataSize = dynamicData_.size();
+    dynamicData_.resize(dynamicDataSize + INT_SIZE + mapBufferSize, 0);
+    // format [length of buffer (int)] + [bytes of MapBuffer]
+    memcpy(dynamicData_.data() + dynamicDataSize, &mapBufferSize, INT_SIZE);
+    // Copy the content of the map into dynamicData_
+    memcpy(
+        dynamicData_.data() + dynamicDataSize + INT_SIZE,
+        mapBuffer.data(),
+        mapBufferSize);
+  }
+
+  // Store Key and pointer to the string
+  storeKeyValue(
+      key,
+      MapBuffer::DataType::Map,
+      reinterpret_cast<uint8_t const *>(&offset),
+      INT_SIZE);
+}
+
+static inline bool compareBuckets(
+    MapBuffer::Bucket const &a,
+    MapBuffer::Bucket const &b) {
+  return a.key < b.key;
+}
+
+MapBuffer MapBufferBuilder::build() {
+  // Create buffer: [header] + [key, values] + [dynamic data]
+  auto bucketSize = buckets_.size() * sizeof(MapBuffer::Bucket);
+  auto headerSize = sizeof(MapBuffer::Header);
+  auto bufferSize = headerSize + bucketSize + dynamicData_.size();
+
+  header_.bufferSize = static_cast<uint32_t>(bufferSize);
+
+  if (needsSort_) {
+    std::sort(buckets_.begin(), buckets_.end(), compareBuckets);
+  }
+
+  // TODO(T83483191): add pass to check for duplicates
+
+  std::vector<uint8_t> buffer(bufferSize);
+  memcpy(buffer.data(), &header_, headerSize);
+  memcpy(buffer.data() + headerSize, buckets_.data(), bucketSize);
+  memcpy(
+      buffer.data() + headerSize + bucketSize,
+      dynamicData_.data(),
+      dynamicData_.size());
+
+  return MapBuffer(std::move(buffer));
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/Yoga.cpp

@@ -303,7 +303,7 @@ YOGA_EXPORT void YGNodeReset(YGNodeRef node) {
   node->reset();
 }
 
-int32_t YGConfigGetInstanceCount(void) {
+YOGA_EXPORT int32_t YGConfigGetInstanceCount(void) {
   return gConfigInstanceCount;
 }
 
@@ -798,6 +798,27 @@ YOGA_EXPORT float YGNodeStyleGetBorder(
   return static_cast<YGValue>(border).value;
 }
 
+YOGA_EXPORT void YGNodeStyleSetGap(
+    const YGNodeRef node,
+    const YGGutter gutter,
+    const float gapLength) {
+  auto length = detail::CompactValue::ofMaybe<YGUnitPoint>(gapLength);
+  updateIndexedStyleProp<MSVC_HINT(gap)>(node, &YGStyle::gap, gutter, length);
+}
+
+YOGA_EXPORT float YGNodeStyleGetGap(
+    const YGNodeConstRef node,
+    const YGGutter gutter) {
+  auto gapLength = node->getStyle().gap()[gutter];
+  if (gapLength.isUndefined() || gapLength.isAuto()) {
+    // TODO(T26792433): Rather than returning YGUndefined, change the api to
+    // return YGFloatOptional.
+    return YGUndefined;
+  }
+
+  return static_cast<YGValue>(gapLength).value;
+}
+
 // Yoga specific properties, not compatible with flexbox specification
 
 // TODO(T26792433): Change the API to accept YGFloatOptional.
@@ -1972,6 +1993,7 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues(
   const YGFlexDirection mainAxis = YGResolveFlexDirection(
       node->getStyle().flexDirection(), node->resolveDirection(ownerDirection));
   const bool isNodeFlexWrap = node->getStyle().flexWrap() != YGWrapNoWrap;
+  const float gap = node->getGapForAxis(mainAxis, availableInnerWidth).unwrap();
 
   // Add items to the current line until it's full or we run out of items.
   uint32_t endOfLineIndex = startOfLineIndex;
@@ -1981,9 +2003,13 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues(
         child->getStyle().positionType() == YGPositionTypeAbsolute) {
       continue;
     }
+
+    const bool isFirstElementInLine = (endOfLineIndex - startOfLineIndex) == 0;
+
     child->setLineIndex(lineCount);
     const float childMarginMainAxis =
         child->getMarginForAxis(mainAxis, availableInnerWidth).unwrap();
+    const float childLeadingGapMainAxis = isFirstElementInLine ? 0.0f : gap;
     const float flexBasisWithMinAndMaxConstraints =
         YGNodeBoundAxisWithinMinAndMax(
             child,
@@ -1996,16 +2022,19 @@ static YGCollectFlexItemsRowValues YGCalculateCollectFlexItemsRowValues(
     // size, we've hit the end of the current line. Break out of the loop and
     // lay out the current line.
     if (sizeConsumedOnCurrentLineIncludingMinConstraint +
-                flexBasisWithMinAndMaxConstraints + childMarginMainAxis >
+                flexBasisWithMinAndMaxConstraints + childMarginMainAxis +
+                childLeadingGapMainAxis >
             availableInnerMainDim &&
         isNodeFlexWrap && flexAlgoRowMeasurement.itemsOnLine > 0) {
       break;
     }
 
     sizeConsumedOnCurrentLineIncludingMinConstraint +=
-        flexBasisWithMinAndMaxConstraints + childMarginMainAxis;
+        flexBasisWithMinAndMaxConstraints + childMarginMainAxis +
+        childLeadingGapMainAxis;
     flexAlgoRowMeasurement.sizeConsumedOnCurrentLine +=
-        flexBasisWithMinAndMaxConstraints + childMarginMainAxis;
+        flexBasisWithMinAndMaxConstraints + childMarginMainAxis +
+        childLeadingGapMainAxis;
     flexAlgoRowMeasurement.itemsOnLine++;
 
     if (child->isNodeFlexible()) {
@@ -2050,7 +2079,7 @@ static float YGDistributeFreeSpaceSecondPass(
     const float availableInnerCrossDim,
     const float availableInnerWidth,
     const float availableInnerHeight,
-    const bool flexBasisOverflows,
+    const bool mainAxisOverflows,
     const YGMeasureMode measureModeCrossDim,
     const bool performLayout,
     const YGConfigRef config,
@@ -2146,7 +2175,7 @@ static float YGDistributeFreeSpaceSecondPass(
         !YGNodeIsStyleDimDefined(
             currentRelativeChild, crossAxis, availableInnerCrossDim) &&
         measureModeCrossDim == YGMeasureModeExactly &&
-        !(isNodeFlexWrap && flexBasisOverflows) &&
+        !(isNodeFlexWrap && mainAxisOverflows) &&
         YGNodeAlignItem(node, currentRelativeChild) == YGAlignStretch &&
         currentRelativeChild->marginLeadingValue(crossAxis).unit !=
             YGUnitAuto &&
@@ -2354,7 +2383,7 @@ static void YGResolveFlexibleLength(
     const float availableInnerCrossDim,
     const float availableInnerWidth,
     const float availableInnerHeight,
-    const bool flexBasisOverflows,
+    const bool mainAxisOverflows,
     const YGMeasureMode measureModeCrossDim,
     const bool performLayout,
     const YGConfigRef config,
@@ -2382,7 +2411,7 @@ static void YGResolveFlexibleLength(
       availableInnerCrossDim,
       availableInnerWidth,
       availableInnerHeight,
-      flexBasisOverflows,
+      mainAxisOverflows,
       measureModeCrossDim,
       performLayout,
       config,
@@ -2415,6 +2444,7 @@ static void YGJustifyMainAxis(
       node->getLeadingPaddingAndBorder(mainAxis, ownerWidth).unwrap();
   const float trailingPaddingAndBorderMain =
       node->getTrailingPaddingAndBorder(mainAxis, ownerWidth).unwrap();
+  const float gap = node->getGapForAxis(mainAxis, ownerWidth).unwrap();
   // If we are using "at most" rules in the main axis, make sure that
   // remainingFreeSpace is 0 when min main dimension is not given
   if (measureModeMainDim == YGMeasureModeAtMost &&
@@ -2462,7 +2492,7 @@ static void YGJustifyMainAxis(
   // The space between the beginning and the first element and the space between
   // each two elements.
   float leadingMainDim = 0;
-  float betweenMainDim = 0;
+  float betweenMainDim = gap;
   const YGJustify justifyContent = node->getStyle().justifyContent();
 
   if (numberOfAutoMarginsOnCurrentLine == 0) {
@@ -2475,24 +2505,22 @@ static void YGJustifyMainAxis(
         break;
       case YGJustifySpaceBetween:
         if (collectedFlexItemsValues.itemsOnLine > 1) {
-          betweenMainDim =
+          betweenMainDim +=
               YGFloatMax(collectedFlexItemsValues.remainingFreeSpace, 0) /
               (collectedFlexItemsValues.itemsOnLine - 1);
-        } else {
-          betweenMainDim = 0;
         }
         break;
       case YGJustifySpaceEvenly:
         // Space is distributed evenly across all elements
-        betweenMainDim = collectedFlexItemsValues.remainingFreeSpace /
+        leadingMainDim = collectedFlexItemsValues.remainingFreeSpace /
             (collectedFlexItemsValues.itemsOnLine + 1);
-        leadingMainDim = betweenMainDim;
+        betweenMainDim += leadingMainDim;
         break;
       case YGJustifySpaceAround:
         // Space on the edges is half of the space between elements
-        betweenMainDim = collectedFlexItemsValues.remainingFreeSpace /
+        leadingMainDim = 0.5f * collectedFlexItemsValues.remainingFreeSpace /
             collectedFlexItemsValues.itemsOnLine;
-        leadingMainDim = betweenMainDim / 2;
+        betweenMainDim += leadingMainDim * 2;
         break;
       case YGJustifyFlexStart:
         break;
@@ -2641,7 +2669,7 @@ static void YGJustifyMainAxis(
 //    but the algorithm below assumes a default of 'column'.
 //
 // Input parameters:
-//    - node: current node to be sized and layed out
+//    - node: current node to be sized and laid out
 //    - availableWidth & availableHeight: available size to be used for sizing
 //      the node or YGUndefined if the size is not available; interpretation
 //      depends on layout flags
@@ -2653,7 +2681,7 @@ static void YGJustifyMainAxis(
 //      for explanation)
 //    - performLayout: specifies whether the caller is interested in just the
 //      dimensions of the node or it requires the entire node and its subtree to
-//      be layed out (with final positions)
+//      be laid out (with final positions)
 //
 // Details:
 //    This routine is called recursively to lay out subtrees of flexbox
@@ -2856,7 +2884,9 @@ static void YGNodelayoutImpl(
 
   // STEP 3: DETERMINE FLEX BASIS FOR EACH ITEM
 
-  float totalOuterFlexBasis = YGNodeComputeFlexBasisForChildren(
+  // Computed basis + margins + gap
+  float totalMainDim = 0;
+  totalMainDim += YGNodeComputeFlexBasisForChildren(
       node,
       availableInnerWidth,
       availableInnerHeight,
@@ -2871,10 +2901,17 @@ static void YGNodelayoutImpl(
       depth,
       generationCount);
 
-  const bool flexBasisOverflows = measureModeMainDim == YGMeasureModeUndefined
-      ? false
-      : totalOuterFlexBasis > availableInnerMainDim;
-  if (isNodeFlexWrap && flexBasisOverflows &&
+  if (childCount > 1) {
+    totalMainDim +=
+        node->getGapForAxis(mainAxis, availableInnerCrossDim).unwrap() *
+        (childCount - 1);
+  }
+
+  const bool mainAxisOverflows =
+      (measureModeMainDim != YGMeasureModeUndefined) &&
+      totalMainDim > availableInnerMainDim;
+
+  if (isNodeFlexWrap && mainAxisOverflows &&
       measureModeMainDim == YGMeasureModeAtMost) {
     measureModeMainDim = YGMeasureModeExactly;
   }
@@ -2890,6 +2927,9 @@ static void YGNodelayoutImpl(
   // Accumulated cross dimensions of all lines so far.
   float totalLineCrossDim = 0;
 
+  const float crossAxisGap =
+      node->getGapForAxis(crossAxis, availableInnerCrossDim).unwrap();
+
   // Max main dimension of all the lines.
   float maxLineMainDim = 0;
   YGCollectFlexItemsRowValues collectedFlexItemsValues;
@@ -2952,10 +2992,10 @@ static void YGNodelayoutImpl(
         availableInnerMainDim = maxInnerMainDim;
       } else {
         if (!node->getConfig()->useLegacyStretchBehaviour &&
-            ((YGFloatIsUndefined(
+            ((!YGFloatIsUndefined(
                   collectedFlexItemsValues.totalFlexGrowFactors) &&
               collectedFlexItemsValues.totalFlexGrowFactors == 0) ||
-             (YGFloatIsUndefined(node->resolveFlexGrow()) &&
+             (!YGFloatIsUndefined(node->resolveFlexGrow()) &&
               node->resolveFlexGrow() == 0))) {
           // If we don't have any children to flex or we can't flex the node
           // itself, space we've used is all space we need. Root node also
@@ -2994,7 +3034,7 @@ static void YGNodelayoutImpl(
           availableInnerCrossDim,
           availableInnerWidth,
           availableInnerHeight,
-          flexBasisOverflows,
+          mainAxisOverflows,
           measureModeCrossDim,
           performLayout,
           config,
@@ -3209,7 +3249,8 @@ static void YGNodelayoutImpl(
       }
     }
 
-    totalLineCrossDim += collectedFlexItemsValues.crossDim;
+    const float appliedCrossGap = lineCount != 0 ? crossAxisGap : 0.0f;
+    totalLineCrossDim += collectedFlexItemsValues.crossDim + appliedCrossGap;
     maxLineMainDim =
         YGFloatMax(maxLineMainDim, collectedFlexItemsValues.mainDim);
   }
@@ -3304,6 +3345,7 @@ static void YGNodelayoutImpl(
       }
       endIndex = ii;
       lineHeight += crossDimLead;
+      currentLead += i != 0 ? crossAxisGap : 0;
 
       if (performLayout) {
         for (ii = startIndex; ii < endIndex; ii++) {
@@ -3790,7 +3832,7 @@ bool YGLayoutNodeInternal(
   // Determine whether the results are already cached. We maintain a separate
   // cache for layouts and measurements. A layout operation modifies the
   // positions and dimensions for nodes in the subtree. The algorithm assumes
-  // that each node gets layed out a maximum of one time per tree layout, but
+  // that each node gets laid out a maximum of one time per tree layout, but
   // multiple measurements may be required to resolve all of the flex
   // dimensions. We handle nodes with measure functions specially here because
   // they are the most expensive to measure, so it's worth avoiding redundant
@@ -4323,7 +4365,7 @@ YOGA_EXPORT void YGConfigSetExperimentalFeatureEnabled(
   config->experimentalFeatures[feature] = enabled;
 }
 
-inline bool YGConfigIsExperimentalFeatureEnabled(
+YOGA_EXPORT bool YGConfigIsExperimentalFeatureEnabled(
     const YGConfigRef config,
     const YGExperimentalFeature feature) {
   return config->experimentalFeatures[feature];
@@ -4335,6 +4377,11 @@ YOGA_EXPORT void YGConfigSetUseWebDefaults(
   config->useWebDefaults = enabled;
 }
 
+YOGA_EXPORT bool YGConfigGetUseLegacyStretchBehaviour(
+    const YGConfigRef config) {
+  return config->useLegacyStretchBehaviour;
+}
+
 YOGA_EXPORT void YGConfigSetUseLegacyStretchBehaviour(
     const YGConfigRef config,
     const bool useLegacyStretchBehaviour) {

package/Scripts/IntegrationTests.ps1

@@ -34,7 +34,7 @@ param (
 
 	[switch] $List,
 
-	[System.IO.FileInfo] $VsTest =	"${env:ProgramFiles(x86)}\Microsoft Visual Studio\2019\Enterprise\" +
+	[System.IO.FileInfo] $VsTest =	"${env:ProgramFiles}\Microsoft Visual Studio\2022\Enterprise\" +
 						"Common7\IDE\CommonExtensions\Microsoft\TestWindow\vstest.console.exe",
 
 	[System.IO.DirectoryInfo] $ReactNativeLocation = "$($PSScriptRoot | Split-Path)",

package/Scripts/JustMyXaml.ps1

@@ -1,4 +1,4 @@
-# This script enables or disables VS 2019's JustMyXaml feature
+# This script enables or disables VS 2022's JustMyXaml feature
 [CmdletBinding()]
 param([bool]$Enable)
 
@@ -7,14 +7,14 @@ if (!([bool](([System.Security.Principal.WindowsIdentity]::GetCurrent()).groups
 }
 
 $instanceId = & "$(${env:ProgramFiles(x86)})\Microsoft Visual Studio\Installer\vswhere.exe" -property instanceId
-$hiveFile = "$($env:LocalAppData)\Microsoft\VisualStudio\16.0_$instanceId\privateregistry.bin"
-& reg.exe load HKLM\VS2019_HIVE $hiveFile | Out-Null
-New-PSDrive -Name VS2019 -PSProvider Registry -Root HKLM\VS2019_HIVE  -ErrorAction Stop | Out-Null
-$currentValue = (Get-ItemProperty VS2019:\Software\Microsoft\VisualStudio\16.0_$instanceId\Debugger -Name EnableXamlVisualDiagnosticsJustMyXaml).EnableXamlVisualDiagnosticsJustMyXaml
+$hiveFile = "$($env:LocalAppData)\Microsoft\VisualStudio\17.0_$instanceId\privateregistry.bin"
+& reg.exe load HKLM\VS2022_HIVE $hiveFile | Out-Null
+New-PSDrive -Name VS2022 -PSProvider Registry -Root HKLM\VS2022_HIVE  -ErrorAction Stop | Out-Null
+$currentValue = (Get-ItemProperty VS2022:\Software\Microsoft\VisualStudio\17.0_$instanceId\Debugger -Name EnableXamlVisualDiagnosticsJustMyXaml).EnableXamlVisualDiagnosticsJustMyXaml
 if ($currentValue -eq 0) { $currentValue = $false; } else { $currentValue = $true; }
 Write-Host "Current value: $currentValue"
 if ($Enable) { $newValue = 1; } else { $newValue = 0; }
-Set-ItemProperty VS2019:\Software\Microsoft\VisualStudio\16.0_$instanceId\Debugger -Name EnableXamlVisualDiagnosticsJustMyXaml -Value $newValue -Type DWord
+Set-ItemProperty VS2022:\Software\Microsoft\VisualStudio\17.0_$instanceId\Debugger -Name EnableXamlVisualDiagnosticsJustMyXaml -Value $newValue -Type DWord
 Write-Host "New value: $Enable"
-Remove-PSDrive -Name VS2019
-& reg.exe unload HKLM\VS2019_HIVE | Out-Null
+Remove-PSDrive -Name VS2022
+& reg.exe unload HKLM\VS2022_HIVE | Out-Null

package/Scripts/Microsoft.ReactNative.Managed.nuspec

@@ -26,7 +26,7 @@
     <file src="$nugetroot$\Microsoft.ReactNative.Managed.targets" target="build"/>
     <file src="$nugetroot$\Microsoft.ReactNative.VersionCheck.targets" target="build"/>
 
-    <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative.Managed\ref.anycpu\Microsoft.ReactNative.Managed.dll" target="ref\uap10.0"/>
+    <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative.Managed\ref\Microsoft.ReactNative.Managed.dll" target="ref\uap10.0"/>
     <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative.Managed\Microsoft.ReactNative.Managed.xml" target="ref\uap10.0"/> 
 
     <!-- Include in Microsoft.ReactNative.Managed -->

package/Scripts/Microsoft.ReactNative.WindowsAppSDK.nuspec

@@ -15,16 +15,16 @@
       <group targetFramework=".NETCoreApp3.0" />
       <group targetFramework="UAP10.0" />
       <group targetFramework=".NETFramework4.6" />
-      <group targetFramework="net5.0" />
+      <group targetFramework="net6.0" />
     </dependencies>
   </metadata>
   <files>
-    <!-- Support netcore3, uap, net46+, net5, c++ -->
+    <!-- Support netcore3, uap, net46+, net6, c++ -->
     <!-- Use the contents in the target folder since those are built with UseWinUI3, as opposed to the content in $nugetroot$ which -->
     <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative\Microsoft.ReactNative.winmd" target="lib\netcoreapp3.0\Microsoft.ReactNative.winmd" />
     <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative\Microsoft.ReactNative.winmd" target="lib\uap10.0\Microsoft.ReactNative.winmd" />
     <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative\Microsoft.ReactNative.winmd" target="lib\net46\Microsoft.ReactNative.winmd" />
     <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x64\native\Microsoft.ReactNative.dll" />
-    <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative.WindowsAppSDK\Microsoft.ReactNative.WindowsAppSDK.dll" target="lib\net5.0\Microsoft.ReactNative.WindowsAppSDK.dll" />
+    <file src="$nugetroot$\$baseplatform$\$baseconfiguration$\Microsoft.ReactNative.WindowsAppSDK\Microsoft.ReactNative.WindowsAppSDK.dll" target="lib\net6.0\Microsoft.ReactNative.WindowsAppSDK.dll" />
   </files>
 </package>

package/Scripts/OfficeReact.Win32.nuspec

@@ -41,9 +41,11 @@
     <file src="$nugetroot$\inc\jsi\**\*.*" target="inc\jsi"/>
     <file src="$nugetroot$\inc\Yoga\*.*" target="inc\Yoga"/>
     <file src="$nugetroot$\inc\folly\**\*.*" target="inc" />
+    <file src="$nugetroot$\inc\fmt\**\*.*" target="inc\fmt" />
     <file src="$nugetroot$\inc\stubs\**\*.*" target="inc" />
 
     <file src="$nugetroot$\inc\Shared\AbiSafe.h" target="inc"/>
+    <file src="$nugetroot$\inc\Shared\Composition\CompositionSwitcher.interop.h" target="inc"/>
     <file src="$nugetroot$\inc\Shared\DevSettings.h" target="inc"/>
     <file src="$nugetroot$\inc\ReactWin32\INativeUIManagerLegacy.h" target="inc"/>
     <file src="$nugetroot$\inc\Shared\InstanceManager.h" target="inc"/>

package/Scripts/Tfs/Layout-Desktop-Headers.ps1

@@ -12,7 +12,12 @@ param(
 [xml]$props = gc $PSScriptRoot\..\..\Directory.Build.props
 [string] $FollyVersion = $props.Project.PropertyGroup.FollyVersion;
 $FollyVersion = $FollyVersion.Trim() # The extracted FollyVersion contains a space at the end that isn't actually present, issue #6216
-$FollyRoot = "$SourceRoot\node_modules\.folly\folly-${FollyVersion}";
+$FollyRoot = "$SourceRoot\node_modules\.folly";
+$FollyOverrideRoot = "$ReactWindowsRoot\Folly\TEMP_UntilFollyUpdate";
+
+[string] $FmtVersion = $props.Project.PropertyGroup.FmtVersion;
+$FmtVersion = $FmtVersion.Trim() # The extracted FmtVersion contains a space at the end that isn't actually present, issue #6216
+$FmtRoot = "$SourceRoot\node_modules\.fmt\fmt-${FmtVersion}";
 
 # Download Folly if running on a machine which hasn't run native build logic to acquire it
 if (!(Test-Path $FollyRoot)) {
@@ -25,6 +30,17 @@ if (!(Test-Path $FollyRoot)) {
 	Expand-Archive -LiteralPath $FollyZip -DestinationPath $FollyRoot
 }
 
+# Download Fmt if running on a machine which hasn't run native build logic to acquire it
+if (!(Test-Path $FmtRoot)) {
+	Write-Host "Downloading Fmt $FmtVersion"
+	$FmtZip = "$SourceRoot\node_modules\.fmt\fmt-${FmtVersion}.zip"
+	$FmtDest = "$SourceRoot\node_modules\.fmt"
+
+	New-Item $FmtRoot -ItemType Directory
+	Invoke-RestMethod -Uri "https://github.com/fmtlib/fmt/archive/refs/tags/$FmtVersion.zip" -OutFile $FmtZip
+	Expand-Archive -LiteralPath $FmtZip -DestinationPath $FmtDest
+}
+
 Write-Host "Source root: [$SourceRoot]"
 Write-Host "Destination root: [$TargetRoot]"
 Write-Host "React Native root: [$ReactNativeRoot]"
@@ -54,6 +70,20 @@ Get-ChildItem -Path $FollyRoot -Name -Recurse -Include $patterns | ForEach-Objec
 	-Force
 }
 
+# Folly overrides
+Get-ChildItem -Path $FollyOverrideRoot -Name -Recurse -Include $patterns | ForEach-Object { Copy-Item `
+	-Path        $FollyOverrideRoot\$_ `
+	-Destination (New-Item -ItemType Directory $TargetRoot\inc\folly\folly-$FollyVersion\folly\$(Split-Path $_) -Force) `
+	-Force
+}
+
+# Fmt headers
+Get-ChildItem -Path $FmtRoot\include -Name -Recurse -Include $patterns | ForEach-Object { Copy-Item `
+	-Path        $FmtRoot\include\$_ `
+	-Destination (New-Item -ItemType Directory $TargetRoot\inc\$(Split-Path $_) -Force) `
+	-Force
+}
+
 # stubs headers
 Get-ChildItem -Path $ReactWindowsRoot\stubs -Name -Recurse -Include $patterns | ForEach-Object { Copy-Item `
 	-Path        $ReactWindowsRoot\stubs\$_ `

package/Scripts/UnitTest.ps1

@@ -23,7 +23,7 @@ param (
 			"ReactCommon.UnitTests\ReactCommon.UnitTests.exe")
 	),
 
-	[System.IO.FileInfo] $VsTest = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\2019\Enterprise\Common7\IDE\CommonExtensions\Microsoft\TestWindow\vstest.console.exe"
+	[System.IO.FileInfo] $VsTest = "${env:ProgramFiles}\Microsoft Visual Studio\2022\Enterprise\Common7\IDE\CommonExtensions\Microsoft\TestWindow\vstest.console.exe"
 )
 
 if ($Include.Count) {