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

package/Microsoft.ReactNative/Views/ViewViewManager.cpp

@@ -46,7 +46,7 @@ class ViewShadowNode : public ShadowNodeBase {
   void createView(const winrt::Microsoft::ReactNative::JSValueObject &props) override {
     Super::createView(props);
 
-    auto panel = GetViewPanel();
+    auto panel = GetPanel();
 
     DynamicAutomationProperties::SetAccessibilityInvokeEventHandler(panel, [=]() {
       if (OnClick())
@@ -126,9 +126,6 @@ class ViewShadowNode : public ShadowNodeBase {
   }
   void IsFocusable(bool isFocusable) {
     m_isFocusable = isFocusable;
-
-    if (IsControl())
-      GetControl().IsTabStop(m_isFocusable);
   }
 
   bool IsAccessible() const {
@@ -153,16 +150,16 @@ class ViewShadowNode : public ShadowNodeBase {
           Microsoft::Common::Unicode::Utf16ToUtf8(name.c_str()));
     }
 
-    GetViewPanel().InsertAt(static_cast<uint32_t>(index), view.as<xaml::UIElement>());
+    GetPanel().Children().InsertAt(static_cast<uint32_t>(index), view.as<xaml::UIElement>());
   }
 
   void RemoveChildAt(int64_t indexToRemove) override {
     if (indexToRemove == static_cast<uint32_t>(indexToRemove))
-      GetViewPanel().RemoveAt(static_cast<uint32_t>(indexToRemove));
+      GetPanel().Children().RemoveAt(static_cast<uint32_t>(indexToRemove));
   }
 
   void removeAllChildren() override {
-    GetViewPanel().Clear();
+    GetPanel().Children().Clear();
 
     XamlView current = m_view;
 
@@ -186,12 +183,12 @@ class ViewShadowNode : public ShadowNodeBase {
   }
 
   void ReplaceChild(const XamlView &oldChildView, const XamlView &newChildView) override {
-    auto pPanel = GetViewPanel();
+    auto pPanel = GetPanel();
     if (pPanel != nullptr) {
       uint32_t index;
       if (pPanel.Children().IndexOf(oldChildView.as<xaml::UIElement>(), index)) {
-        pPanel.RemoveAt(index);
-        pPanel.InsertAt(index, newChildView.as<xaml::UIElement>());
+        pPanel.Children().RemoveAt(index);
+        pPanel.Children().InsertAt(index, newChildView.as<xaml::UIElement>());
       } else {
         assert(false);
       }
@@ -207,7 +204,7 @@ class ViewShadowNode : public ShadowNodeBase {
     static_cast<FrameworkElementViewManager *>(GetViewManager())->RefreshTransformMatrix(this);
   }
 
-  winrt::Microsoft::ReactNative::ViewPanel GetViewPanel() {
+  xaml::Controls::Panel GetPanel() {
     XamlView current = m_view;
 
     if (IsControl()) {
@@ -222,7 +219,7 @@ class ViewShadowNode : public ShadowNodeBase {
       }
     }
 
-    auto panel = current.try_as<winrt::Microsoft::ReactNative::ViewPanel>();
+    auto panel = current.try_as<xaml::Controls::Panel>();
     assert(panel != nullptr);
 
     return panel;
@@ -402,41 +399,57 @@ bool ViewViewManager::UpdateProperty(
     const winrt::Microsoft::ReactNative::JSValue &propertyValue) {
   auto *pViewShadowNode = static_cast<ViewShadowNode *>(nodeToUpdate);
 
-  auto pPanel = pViewShadowNode->GetViewPanel();
+  auto pPanel = pViewShadowNode->GetPanel().as<winrt::Microsoft::ReactNative::ViewPanel>();
   bool ret = true;
   if (pPanel != nullptr) {
     if (TryUpdateBackgroundBrush(pPanel, propertyName, propertyValue)) {
     } else if (TryUpdateBorderProperties(nodeToUpdate, pPanel, propertyName, propertyValue)) {
     } else if (TryUpdateCornerRadiusOnNode(nodeToUpdate, pPanel, propertyName, propertyValue)) {
-      UpdateCornerRadiusOnElement(nodeToUpdate, pPanel);
+      // Do not clamp until a size has been set for the View
+      auto maxCornerRadius = std::numeric_limits<double>::max();
+      // The Width and Height properties are not always set on ViewPanel. In
+      // cases where it is embedded in a Control or outer Border, the values
+      // dimensions are set on those wrapper elements. We cannot depend on the
+      // default behavior of `UpdateCornerRadiusOnElement` to check for the
+      // clamp dimension from only the ViewPanel.
+      const xaml::FrameworkElement sizingElement = pViewShadowNode->IsControl() ? pViewShadowNode->GetControl()
+          : pViewShadowNode->HasOuterBorder() ? pPanel.GetOuterBorder().as<xaml::FrameworkElement>()
+                                              : pPanel;
+      if (sizingElement.ReadLocalValue(xaml::FrameworkElement::WidthProperty()) !=
+              xaml::DependencyProperty::UnsetValue() &&
+          sizingElement.ReadLocalValue(xaml::FrameworkElement::HeightProperty()) !=
+              xaml::DependencyProperty::UnsetValue()) {
+        maxCornerRadius = std::min(sizingElement.Width(), sizingElement.Height()) / 2;
+      }
+      UpdateCornerRadiusOnElement(nodeToUpdate, pPanel, maxCornerRadius);
     } else if (TryUpdateMouseEvents(nodeToUpdate, propertyName, propertyValue)) {
     } else if (propertyName == "onClick") {
-      pViewShadowNode->OnClick(!propertyValue.IsNull() && propertyValue.AsBoolean());
+      pViewShadowNode->OnClick(propertyValue.AsBoolean());
     } else if (propertyName == "overflow") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
         bool clipChildren = propertyValue.AsString() == "hidden";
         pPanel.ClipChildren(clipChildren);
       }
     } else if (propertyName == "focusable") {
-      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
-        pViewShadowNode->IsFocusable(propertyValue.AsBoolean());
+      pViewShadowNode->IsFocusable(propertyValue.AsBoolean());
     } else if (propertyName == "enableFocusRing") {
-      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
-        pViewShadowNode->EnableFocusRing(propertyValue.AsBoolean());
-      else if (propertyValue.IsNull())
-        pViewShadowNode->EnableFocusRing(false);
+      pViewShadowNode->EnableFocusRing(propertyValue.AsBoolean());
     } else if (propertyName == "tabIndex") {
-      auto tabIndex = propertyValue.AsInt64();
-      if (tabIndex == static_cast<int32_t>(tabIndex)) {
-        pViewShadowNode->TabIndex(static_cast<int32_t>(tabIndex));
-      } else if (propertyValue.IsNull()) {
+      auto resetTabIndex = true;
+      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64 ||
+          propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double) {
+        const auto tabIndex = propertyValue.AsInt64();
+        if (tabIndex == static_cast<int32_t>(tabIndex)) {
+          pViewShadowNode->TabIndex(static_cast<int32_t>(tabIndex));
+          resetTabIndex = false;
+        }
+      }
+      if (resetTabIndex) {
         pViewShadowNode->TabIndex(std::numeric_limits<std::int32_t>::max());
       }
     } else {
       if (propertyName == "accessible") {
-        if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
-          pViewShadowNode->IsAccessible(propertyValue.AsBoolean());
-        }
+        pViewShadowNode->IsAccessible(propertyValue.AsBoolean());
       }
       ret = Super::UpdateProperty(nodeToUpdate, propertyName, propertyValue);
     }
@@ -447,7 +460,7 @@ bool ViewViewManager::UpdateProperty(
 
 void ViewViewManager::OnPropertiesUpdated(ShadowNodeBase *node) {
   auto *viewShadowNode = static_cast<ViewShadowNode *>(node);
-  auto panel = viewShadowNode->GetViewPanel();
+  auto panel = viewShadowNode->GetPanel().as<winrt::Microsoft::ReactNative::ViewPanel>();
 
   if (panel.ReadLocalValue(ViewPanel::ViewBackgroundProperty()) == xaml::DependencyProperty::UnsetValue()) {
     // In XAML, a null background means no hit-test will happen.
@@ -461,7 +474,10 @@ void ViewViewManager::OnPropertiesUpdated(ShadowNodeBase *node) {
     // keep it around, so not adding that code (yet).
   }
 
-  bool shouldBeControl = viewShadowNode->IsFocusable();
+  // If component is focusable, it should be a ViewControl.
+  // If component is a View with accessible set to true, the component should be focusable, thus we need a ViewControl.
+  bool shouldBeControl =
+      (viewShadowNode->IsFocusable() || (viewShadowNode->IsAccessible() && !viewShadowNode->OnClick()));
   if (auto view = viewShadowNode->GetView().try_as<xaml::UIElement>()) {
     // If we have DynamicAutomationProperties, we need a ViewControl with a
     // DynamicAutomationPeer
@@ -471,6 +487,7 @@ void ViewViewManager::OnPropertiesUpdated(ShadowNodeBase *node) {
   panel.FinalizeProperties();
 
   TryUpdateView(viewShadowNode, panel, shouldBeControl);
+  SyncFocusableAndAccessible(viewShadowNode, shouldBeControl);
 }
 
 void ViewViewManager::TryUpdateView(
@@ -583,11 +600,23 @@ void ViewViewManager::TryUpdateView(
 
   if (useControl)
     pViewShadowNode->GetControl().Content(visualRoot);
+}
 
-  if (useControl && pViewShadowNode->IsAccessible() != pViewShadowNode->IsFocusable()) {
-    pViewShadowNode->GetControl().IsTabStop(false);
-    xaml::Automation::AutomationProperties::SetAccessibilityView(
-        pViewShadowNode->GetControl(), xaml::Automation::Peers::AccessibilityView::Raw);
+void ViewViewManager::SyncFocusableAndAccessible(ViewShadowNode *pViewShadowNode, bool useControl) {
+  // If developer specifies either the accessible and focusable prop to be false
+  // remove accessibility and keyboard focus for component. Exception is made
+  // for case where a View with undefined onPress is specified, where
+  // component gains accessibility focus when either the accessible and focusable prop are true.
+  if (useControl) {
+    const auto isFocusable = pViewShadowNode->IsFocusable();
+    const auto isAccessible = pViewShadowNode->IsAccessible();
+    const auto isPressable = pViewShadowNode->OnClick();
+    const auto isTabStop =
+        (isPressable && isFocusable && isAccessible) || (!isPressable && (isFocusable || isAccessible));
+    const auto accessibilityView = isTabStop ? xaml::Automation::Peers::AccessibilityView::Content
+                                             : xaml::Automation::Peers::AccessibilityView::Raw;
+    pViewShadowNode->GetControl().IsTabStop(isTabStop);
+    xaml::Automation::AutomationProperties::SetAccessibilityView(pViewShadowNode->GetControl(), accessibilityView);
   }
 }
 
@@ -603,13 +632,23 @@ void ViewViewManager::SetLayoutProps(
   // Do this first so that it is setup properly before any events are fired by
   // the Super implementation
   auto *pViewShadowNode = static_cast<ViewShadowNode *>(&nodeToUpdate);
+  auto pPanel = pViewShadowNode->GetPanel().as<winrt::Microsoft::ReactNative::ViewPanel>();
   if (pViewShadowNode->IsControl()) {
-    auto pPanel = pViewShadowNode->GetViewPanel();
     pPanel.Width(width);
     pPanel.Height(height);
   }
 
   Super::SetLayoutProps(nodeToUpdate, viewToUpdate, left, top, width, height);
+  if (pPanel.ReadLocalValue(ViewPanel::CornerRadiusProperty()) != xaml::DependencyProperty::UnsetValue()) {
+    // Rather than use ViewPanel::FinalizeProperties, only perform the explicit
+    // logic required to propagate the CornerRadius value to the Border parent.
+    auto border = pPanel.GetOuterBorder();
+    if (border) {
+      const auto maxCornerRadius = std::min(width, height) / 2;
+      UpdateCornerRadiusOnElement(&nodeToUpdate, pPanel, maxCornerRadius);
+      border.CornerRadius(pPanel.CornerRadius());
+    }
+  }
 }
 
 xaml::Media::SolidColorBrush ViewViewManager::EnsureTransparentBrush() {

package/Microsoft.ReactNative/Views/ViewViewManager.h

@@ -41,6 +41,7 @@ class ViewViewManager : public FrameworkElementViewManager {
 
   XamlView CreateViewCore(int64_t tag, const winrt::Microsoft::ReactNative::JSValueObject &) override;
   void TryUpdateView(ViewShadowNode *viewShadowNode, winrt::Microsoft::ReactNative::ViewPanel &pPanel, bool useControl);
+  void SyncFocusableAndAccessible(ViewShadowNode *viewShadowNode, bool useControl);
 
   xaml::Media::SolidColorBrush EnsureTransparentBrush();
 

package/Microsoft.ReactNative/Views/cppwinrt/ViewPanel.idl

@@ -15,11 +15,11 @@ namespace Microsoft.ReactNative
 
     // Public Methods
     void InsertAt(UInt32 index, XAML_NAMESPACE.UIElement value);
-      void RemoveAt(UInt32 index);
-      void Clear();
+    void RemoveAt(UInt32 index);
+    void Clear();
 
     void FinalizeProperties();
-      XAML_NAMESPACE.Controls.Border GetOuterBorder();
+    XAML_NAMESPACE.Controls.Border GetOuterBorder();
 
     // Public Properties
     XAML_NAMESPACE.Media.Brush ViewBackground { get; set; };
@@ -51,6 +51,6 @@ namespace Microsoft.ReactNative
   {
     ViewControl();
 
-    ViewPanel GetPanel();
+    XAML_NAMESPACE.Controls.Panel GetPanel();
   }
 }

package/Microsoft.ReactNative/XamlHelper.cpp

@@ -7,6 +7,7 @@
 
 #include <Utils/ValueUtils.h>
 #include "DynamicWriter.h"
+#include "XamlView.h"
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
@@ -20,6 +21,18 @@ Windows::UI::Color XamlHelper::ColorFrom(JSValueArgWriter const &valueProvider)
   return ::Microsoft::ReactNative::ColorFrom(value);
 }
 
+xaml::DependencyProperty XamlHelper::ReactTagProperty() noexcept {
+  return ::Microsoft::ReactNative::ReactTagProperty();
+}
+
+int64_t XamlHelper::GetReactTag(xaml::DependencyObject const &dependencyObject) noexcept {
+  return ::Microsoft::ReactNative::GetTag(dependencyObject);
+}
+
+void XamlHelper::SetReactTag(xaml::DependencyObject const &dependencyObject, int64_t tag) noexcept {
+  return ::Microsoft::ReactNative::SetTag(dependencyObject, tag);
+}
+
 folly::dynamic XamlHelper::GetFollyDynamicFromValueProvider(JSValueArgWriter const &valueProvider) noexcept {
   auto writer = winrt::make_self<DynamicWriter>();
   valueProvider(*writer);

package/Microsoft.ReactNative/XamlHelper.h

@@ -13,6 +13,10 @@ struct XamlHelper : XamlHelperT<XamlHelper> {
   static xaml::Media::Brush BrushFrom(JSValueArgWriter const &valueProvider) noexcept;
   static Windows::UI::Color ColorFrom(JSValueArgWriter const &valueProvider) noexcept;
 
+  static xaml::DependencyProperty ReactTagProperty() noexcept;
+  static int64_t GetReactTag(xaml::DependencyObject const &dependencyObject) noexcept;
+  static void SetReactTag(xaml::DependencyObject const &dependencyObject, int64_t tag) noexcept;
+
   static folly::dynamic GetFollyDynamicFromValueProvider(JSValueArgWriter const &valueProvider) noexcept;
 };
 

package/Microsoft.ReactNative/XamlHelper.idl

@@ -17,5 +17,14 @@ namespace Microsoft.ReactNative
 
     DOC_STRING("Returns a Color from @JSValueArgWriter.")
     static Windows.UI.Color ColorFrom(JSValueArgWriter valueProvider);
+
+    DOC_STRING("Returns the attached property where the react tag is stored on a XAML Dependency Object.")
+    static XAML_NAMESPACE.DependencyProperty ReactTagProperty { get; };
+    
+    DOC_STRING("Gets the react tag from a backing XAML element.")
+    static Int64 GetReactTag(XAML_NAMESPACE.DependencyObject dependencyObject);
+
+    DOC_STRING("Sets the react tag for a XAML element.")
+    static void SetReactTag(XAML_NAMESPACE.DependencyObject dependencyObject, Int64 tag);
   };
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/XamlUIService.cpp

@@ -9,6 +9,7 @@
 #include "DynamicWriter.h"
 #include "ShadowNodeBase.h"
 #include "Views/ShadowNodeBase.h"
+#include "XamlView.h"
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
@@ -49,6 +50,21 @@ void XamlUIService::DispatchEvent(
   m_context->CallJSFunction("RCTEventEmitter", "receiveEvent", std::move(params));
 }
 
+winrt::Microsoft::ReactNative::ReactRootView XamlUIService::GetReactRootView(
+    xaml::FrameworkElement const &view) noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    const auto reactTag = ::Microsoft::ReactNative::GetTag(view);
+    if (auto shadowNode = static_cast<::Microsoft::ReactNative::ShadowNodeBase *>(
+            uiManager->getHost()->FindShadowNodeForTag(reactTag))) {
+      if (auto rootNode = static_cast<::Microsoft::ReactNative::ShadowNodeBase *>(
+              uiManager->getHost()->FindShadowNodeForTag(shadowNode->m_rootTag))) {
+        return rootNode->GetView().as<winrt::Microsoft::ReactNative::ReactRootView>();
+      }
+    }
+  }
+  return nullptr;
+}
+
 /*static*/ ReactPropertyId<XamlUIService> XamlUIService::XamlUIServiceProperty() noexcept {
   static ReactPropertyId<XamlUIService> uiManagerProperty{L"ReactNative.UIManager", L"XamlUIManager"};
   return uiManagerProperty;

package/Microsoft.ReactNative/XamlUIService.h

@@ -22,6 +22,8 @@ struct XamlUIService : XamlUIServiceT<XamlUIService> {
       hstring const &eventName,
       JSValueArgWriter const &eventDataArgWriter) noexcept;
 
+  winrt::Microsoft::ReactNative::ReactRootView GetReactRootView(xaml::FrameworkElement const &view) noexcept;
+
   static void SetXamlRoot(IReactPropertyBag const &properties, xaml::XamlRoot const &xamlRoot) noexcept;
   static void SetAccessibleRoot(
       IReactPropertyBag const &properties,

package/Microsoft.ReactNative/XamlUIService.idl

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 import "IReactContext.idl";
+import "ReactRootView.idl";
 
 #include "NamespaceRedirect.h"
 #include "DocString.h"
@@ -24,6 +25,9 @@ namespace Microsoft.ReactNative
     DOC_STRING("Dispatches an event to a JS component.")
     void DispatchEvent(XAML_NAMESPACE.FrameworkElement view, String eventName, JSValueArgWriter eventDataArgWriter);
 
+    DOC_STRING("Gets the @ReactRootView view for a given element.")
+    ReactRootView GetReactRootView(XAML_NAMESPACE.FrameworkElement view);
+
     DOC_STRING(
       "Sets the @Windows.UI.Xaml.XamlRoot element for the app. "
       "This must be manually provided to the @ReactInstanceSettings object when using XAML Islands "

package/Microsoft.ReactNative/XamlView.cpp

@@ -11,6 +11,16 @@
 
 namespace Microsoft::ReactNative {
 
+xaml::DependencyProperty ReactTagProperty() noexcept {
+  static xaml::DependencyProperty s_tagProperty = xaml::DependencyProperty::RegisterAttached(
+      L"ReactTag",
+      winrt::xaml_typename<int64_t>(),
+      winrt::xaml_typename<XamlView>(),
+      xaml::PropertyMetadata(winrt::box_value(InvalidTag)));
+
+  return s_tagProperty;
+}
+
 xaml::XamlRoot TryGetXamlRoot(const XamlView &view) {
   xaml::XamlRoot root{nullptr};
   if (auto uielement = view.try_as<xaml::UIElement>()) {

package/Microsoft.ReactNative/XamlView.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <winrt/Windows.UI.Xaml.Interop.h>
 #include "CppWinRTIncludes.h"
 
 namespace Microsoft::ReactNative {
@@ -10,8 +11,10 @@ namespace Microsoft::ReactNative {
 using XamlView = xaml::DependencyObject;
 constexpr int64_t InvalidTag = -1;
 
+xaml::DependencyProperty ReactTagProperty() noexcept;
+
 inline int64_t GetTag(XamlView view) {
-  auto tagValue = view.ReadLocalValue(xaml::FrameworkElement::TagProperty());
+  auto tagValue = view.ReadLocalValue(ReactTagProperty());
   if (tagValue != xaml::DependencyProperty::UnsetValue()) {
     if (auto tagValueInt = tagValue.try_as<winrt::IPropertyValue>()) {
       if (tagValueInt.Type() == winrt::PropertyType::Int64) {
@@ -24,6 +27,8 @@ inline int64_t GetTag(XamlView view) {
 }
 
 inline void SetTag(XamlView view, int64_t tag) {
+  view.SetValue(ReactTagProperty(), winrt::PropertyValue::CreateInt64(tag));
+  // Kept here to maintain compatibility with external ViewManagers who expect FE::Tag to contain the react tag
   view.SetValue(xaml::FrameworkElement::TagProperty(), winrt::PropertyValue::CreateInt64(tag));
 }
 
@@ -43,7 +48,7 @@ inline int64_t GetTag(winrt::IPropertyValue value) {
 
 inline winrt::IPropertyValue GetTagAsPropertyValue(XamlView view) {
   assert(view);
-  return view.GetValue(xaml::FrameworkElement::TagProperty()).try_as<winrt::IPropertyValue>();
+  return view.GetValue(ReactTagProperty()).try_as<winrt::IPropertyValue>();
 }
 
 xaml::XamlRoot TryGetXamlRoot(const XamlView &view);

package/Microsoft.ReactNative.Cxx/JSI/JsiAbiApi.cpp

@@ -320,6 +320,82 @@ PropNameID JsiAbiRuntime::createPropNameIDFromSymbol(const Symbol &sym) try {
   throw;
 }
 
+BigInt JsiAbiRuntime::createBigIntFromInt64(int64_t val) try {
+  return MakeBigInt(m_runtime.CreateBigIntFromInt64(val));
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+BigInt JsiAbiRuntime::createBigIntFromUint64(uint64_t val) try {
+  return MakeBigInt(m_runtime.CreateBigIntFromUint64(val));
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+bool JsiAbiRuntime::bigintIsInt64(const BigInt &bigint) try {
+  JsiBigIntRef ref = AsJsiBigIntRef(bigint);
+  return m_runtime.BigintIsInt64(ref);
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+bool JsiAbiRuntime::bigintIsUint64(const BigInt &bigint) try {
+  JsiBigIntRef ref = AsJsiBigIntRef(bigint);
+  return m_runtime.BigintIsUint64(ref);
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+uint64_t JsiAbiRuntime::truncate(const BigInt &bigint) try {
+  JsiBigIntRef ref = AsJsiBigIntRef(bigint);
+  return m_runtime.Truncate(ref);
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+String JsiAbiRuntime::bigintToString(const BigInt &bigint, int radix) try {
+  JsiBigIntRef ref = AsJsiBigIntRef(bigint);
+  return MakeString(m_runtime.BigintToString(ref, radix));
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+bool JsiAbiRuntime::hasNativeState(const Object &obj) try {
+  // TODO: implement
+  UNREFERENCED_PARAMETER(obj);
+  VerifyElseCrash(false);
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+std::shared_ptr<NativeState> JsiAbiRuntime::getNativeState(const Object &obj) try {
+  // TODO: implement
+  UNREFERENCED_PARAMETER(obj);
+  VerifyElseCrash(false);
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+
+void JsiAbiRuntime::setNativeState(const Object &obj, std::shared_ptr<NativeState> state) try {
+  // TODO: implement
+  UNREFERENCED_PARAMETER(obj);
+  UNREFERENCED_PARAMETER(state);
+  VerifyElseCrash(false);
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+
+ArrayBuffer JsiAbiRuntime::createArrayBuffer(std::shared_ptr<MutableBuffer> buffer) try {
+  // TODO: implement
+  UNREFERENCED_PARAMETER(buffer);
+  VerifyElseCrash(false);
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+
 std::string JsiAbiRuntime::utf8(const PropNameID &propertyId) try {
   std::string dataResult;
   m_runtime.PropertyIdToUtf8(AsJsiPropertyIdRef(propertyId), [&dataResult](array_view<uint8_t const> utf8) {

package/Microsoft.ReactNative.Cxx/JSI/JsiAbiApi.h

@@ -97,6 +97,19 @@ struct JsiAbiRuntime : facebook::jsi::Runtime {
   PointerValue *cloneObject(const PointerValue *pv) override;
   PointerValue *clonePropNameID(const PointerValue *pv) override;
 
+  facebook::jsi::BigInt createBigIntFromInt64(int64_t value) override;
+  facebook::jsi::BigInt createBigIntFromUint64(uint64_t value) override;
+  bool bigintIsInt64(const facebook::jsi::BigInt &) override;
+  bool bigintIsUint64(const facebook::jsi::BigInt &) override;
+  uint64_t truncate(const facebook::jsi::BigInt &) override;
+  facebook::jsi::String bigintToString(const facebook::jsi::BigInt &, int) override;
+
+  bool hasNativeState(const facebook::jsi::Object &) override;
+  std::shared_ptr<facebook::jsi::NativeState> getNativeState(const facebook::jsi::Object &) override;
+  void setNativeState(const facebook::jsi::Object &, std::shared_ptr<facebook::jsi::NativeState> state) override;
+
+  facebook::jsi::ArrayBuffer createArrayBuffer(std::shared_ptr<facebook::jsi::MutableBuffer> buffer) override;
+
   facebook::jsi::PropNameID createPropNameIDFromAscii(const char *str, size_t length) override;
   facebook::jsi::PropNameID createPropNameIDFromUtf8(const uint8_t *utf8, size_t length) override;
   facebook::jsi::PropNameID createPropNameIDFromString(const facebook::jsi::String &str) override;

package/Microsoft.ReactNative.Cxx/JSI/NodeApiJsiRuntime.cpp

@@ -3,11 +3,10 @@
 
 #define NAPI_EXPERIMENTAL
 
+#include "pch.h"
 #include "NodeApiJsiRuntime.h"
 
 // Standard Library
-#include <array>
-#include <sstream>
 #include <string_view>
 #include <unordered_set>
 
@@ -144,6 +143,23 @@ struct NapiJsiRuntime : facebook::jsi::Runtime {
   std::string utf8(const facebook::jsi::PropNameID &id) override;
   bool compare(const facebook::jsi::PropNameID &lhs, const facebook::jsi::PropNameID &rhs) override;
 
+  // new
+
+  facebook::jsi::BigInt createBigIntFromInt64(int64_t value) override;
+  facebook::jsi::BigInt createBigIntFromUint64(uint64_t value) override;
+  bool bigintIsInt64(const facebook::jsi::BigInt &) override;
+  bool bigintIsUint64(const facebook::jsi::BigInt &) override;
+  uint64_t truncate(const facebook::jsi::BigInt &) override;
+  facebook::jsi::String bigintToString(const facebook::jsi::BigInt &, int) override;
+
+  bool hasNativeState(const facebook::jsi::Object &) override;
+  std::shared_ptr<facebook::jsi::NativeState> getNativeState(const facebook::jsi::Object &) override;
+  void setNativeState(const facebook::jsi::Object &, std::shared_ptr<facebook::jsi::NativeState> state) override;
+
+  facebook::jsi::ArrayBuffer createArrayBuffer(std::shared_ptr<facebook::jsi::MutableBuffer> buffer);
+
+  // end
+
   std::string symbolToString(const facebook::jsi::Symbol &s) override;
 
   facebook::jsi::String createStringFromAscii(const char *str, size_t length) override;
@@ -728,6 +744,57 @@ PropNameID NapiJsiRuntime::createPropNameIDFromSymbol(const Symbol &sym) {
   return MakePointer<PropNameID>(propSym);
 }
 
+facebook::jsi::BigInt NapiJsiRuntime::createBigIntFromInt64(int64_t val) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+facebook::jsi::BigInt NapiJsiRuntime::createBigIntFromUint64(uint64_t val) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+  ;
+}
+
+bool NapiJsiRuntime::bigintIsInt64(const facebook::jsi::BigInt &) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+bool NapiJsiRuntime::bigintIsUint64(const facebook::jsi::BigInt &) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+uint64_t NapiJsiRuntime::truncate(const facebook::jsi::BigInt &) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+String NapiJsiRuntime::bigintToString(const facebook::jsi::BigInt &, int) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+bool NapiJsiRuntime::hasNativeState(const facebook::jsi::Object &) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+std::shared_ptr<facebook::jsi::NativeState> NapiJsiRuntime::getNativeState(const facebook::jsi::Object &) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+void NapiJsiRuntime::setNativeState(const Object &, std::shared_ptr<facebook::jsi::NativeState> state) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
+facebook::jsi::ArrayBuffer NapiJsiRuntime::createArrayBuffer(std::shared_ptr<facebook::jsi::MutableBuffer> buffer) {
+  EnvScope scope{m_env};
+  throw JSINativeException("Not implemented");
+}
+
 string NapiJsiRuntime::utf8(const PropNameID &id) {
   EnvScope scope{m_env};
 
@@ -1994,6 +2061,8 @@ napi_value NapiJsiRuntime::GetNapiValue(const Value &value) const {
     return GetNapiValue(value.getString(*const_cast<NapiJsiRuntime *>(this)));
   } else if (value.isObject()) {
     return GetNapiValue(value.getObject(*const_cast<NapiJsiRuntime *>(this)));
+  } else if (value.isBigInt()) {
+    return GetNapiValue(value.getBigInt(*const_cast<NapiJsiRuntime *>(this)));
   } else {
     throw JSINativeException("Unexpected jsi::Value type");
   }

package/Microsoft.ReactNative.Cxx/JSI/NodeApiJsiRuntime.h

@@ -5,13 +5,13 @@
 #ifndef MICROSOFT_REACTNATIVE_JSI_NODEAPIJSIRUNTIME
 #define MICROSOFT_REACTNATIVE_JSI_NODEAPIJSIRUNTIME
 
-// Standard Library
-#include <memory>
-
 // JSI
 #include <js_native_ext_api.h>
 #include <jsi/jsi.h>
 
+// Standard Library
+#include <memory>
+
 namespace Microsoft::JSI {
 
 ///

package/Microsoft.ReactNative.Cxx/Microsoft.ReactNative.Cxx.vcxitems

@@ -128,9 +128,8 @@
   <ItemGroup>
     <None Include="$(MSBuildThisFileDirectory)README.md" />
   </ItemGroup>
-  <ItemGroup Condition="'$(BuildMSRNCxx)' != 'false' and '$(RNExternalReferences)' != 'true'">
+  <ItemGroup>
     <ClCompile Include="$(MSBuildThisFileDirectory)JSI\NodeApiJsiRuntime.cpp">
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <ExcludedFromBuild Condition="'$(UseV8)' != 'true'">true</ExcludedFromBuild>
     </ClCompile>
   </ItemGroup>