react-native-windows 0.69.6 → 0.70.0

package/Microsoft.ReactNative/Views/FrameworkElementViewManager.cpp

@@ -93,8 +93,8 @@ static void GetAccessibilityStateProps(const winrt::Microsoft::ReactNative::IJSV
 
 static void GetAccessibilityValueProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) {
   writer.WriteObjectBegin();
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"min", L"boolean");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"max", L"boolean");
+  winrt::Microsoft::ReactNative::WriteProperty(writer, L"min", L"number");
+  winrt::Microsoft::ReactNative::WriteProperty(writer, L"max", L"number");
   winrt::Microsoft::ReactNative::WriteProperty(writer, L"now", L"number");
   winrt::Microsoft::ReactNative::WriteProperty(writer, L"text", L"string");
   writer.WriteObjectEnd();
@@ -235,12 +235,12 @@ bool FrameworkElementViewManager::UpdateProperty(
                 MultiplyInto(
                     transformMatrix,
                     winrt::Windows::Foundation::Numerics::float4x4(
-                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(innerValue.AsSingle(), 0.f)));
+                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(ToRadians(innerValue), 0.f)));
               } else if (transformType == "skewY") {
                 MultiplyInto(
                     transformMatrix,
                     winrt::Windows::Foundation::Numerics::float4x4(
-                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(0.f, innerValue.AsSingle())));
+                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(0.f, ToRadians(innerValue))));
               }
             }
           }
@@ -526,29 +526,79 @@ bool FrameworkElementViewManager::UpdateProperty(
       DynamicAutomationProperties::SetAccessibilityStateCollapsed(
           element, states[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityStates::Collapsed)]);
     } else if (propertyName == "accessibilityValue") {
+      winrt::hstring textValue;
+      const int numericValuesCount = 3;
+      double numericValues[numericValuesCount] = {};
+
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Object) {
         for (const auto &pair : propertyValue.AsObject()) {
           const std::string &innerName = pair.first;
           const auto &innerValue = pair.second;
 
+          auto peer = xaml::Automation::Peers::FrameworkElementAutomationPeer::FromElement(element);
+
           if (innerName == "min" &&
               (innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
                innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64)) {
-            DynamicAutomationProperties::SetAccessibilityValueMin(element, innerValue.AsDouble());
+            numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Min)] =
+                innerValue.AsDouble();
+
+            const auto prevMinValue = DynamicAutomationProperties::GetAccessibilityValueMin(element);
+            if (peer != nullptr && prevMinValue != innerValue.AsDouble()) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::RangeValuePatternIdentifiers::MinimumProperty(),
+                  winrt::box_value(prevMinValue),
+                  winrt::box_value(innerValue.AsDouble()));
+            }
           } else if (
-              innerName == "max" && innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
-              innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
-            DynamicAutomationProperties::SetAccessibilityValueMax(element, innerValue.AsDouble());
+              innerName == "max" &&
+              (innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
+               innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64)) {
+            numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Max)] =
+                innerValue.AsDouble();
+
+            const auto prevMaxValue = DynamicAutomationProperties::GetAccessibilityValueMax(element);
+            if (peer != nullptr && prevMaxValue != innerValue.AsDouble()) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::RangeValuePatternIdentifiers::MaximumProperty(),
+                  winrt::box_value(prevMaxValue),
+                  winrt::box_value(innerValue.AsDouble()));
+            }
           } else if (
-              innerName == "now" && innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
-              innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
-            DynamicAutomationProperties::SetAccessibilityValueNow(element, innerValue.AsDouble());
+              innerName == "now" &&
+              (innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
+               innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64)) {
+            numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Now)] =
+                innerValue.AsDouble();
+
+            const auto prevNowValue = DynamicAutomationProperties::GetAccessibilityValueNow(element);
+            if (peer != nullptr && prevNowValue != innerValue.AsDouble()) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::RangeValuePatternIdentifiers::ValueProperty(),
+                  winrt::box_value(prevNowValue),
+                  winrt::box_value(innerValue.AsDouble()));
+            }
           } else if (innerName == "text" && innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
-            auto value = asHstring(innerValue);
-            DynamicAutomationProperties::SetAccessibilityValueText(element, value);
+            textValue = asHstring(innerValue);
+
+            const auto prevTextValue = DynamicAutomationProperties::GetAccessibilityValueText(element);
+            if (peer != nullptr && prevTextValue != textValue) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::ValuePatternIdentifiers::ValueProperty(),
+                  winrt::box_value(prevTextValue),
+                  winrt::box_value(textValue));
+            }
           }
         }
       }
+
+      DynamicAutomationProperties::SetAccessibilityValueMin(
+          element, numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Min)]);
+      DynamicAutomationProperties::SetAccessibilityValueMax(
+          element, numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Max)]);
+      DynamicAutomationProperties::SetAccessibilityValueNow(
+          element, numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Now)]);
+      DynamicAutomationProperties::SetAccessibilityValueText(element, textValue);
     } else if (propertyName == "testID") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
         auto value = asHstring(propertyValue);

package/Microsoft.ReactNative/Views/Image/ImageViewManager.cpp

@@ -14,8 +14,8 @@
 #include <IReactInstance.h>
 #include <Utils/PropertyHandlerUtils.h>
 #include <Utils/PropertyUtils.h>
+#include <Views/DynamicAutomationProperties.h>
 #include <Views/ShadowNodeBase.h>
-#include "DynamicAutomationProperties.h"
 #include "ReactImage.h"
 
 namespace winrt {

package/Microsoft.ReactNative/Views/Image/ReactImage.cpp

@@ -13,7 +13,7 @@
 #include <winrt/Windows.Web.Http.h>
 
 #include <Utils/ValueUtils.h>
-#include "DynamicAutomationPeer.h"
+#include <Views/DynamicAutomationPeer.h>
 #include "Unicode.h"
 #include "XamlView.h"
 #include "cdebug.h"
@@ -171,8 +171,7 @@ void ReactImage::Source(ReactImageSource source) {
   }
 }
 
-winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> ReactImage::GetImageMemoryStreamAsync(
-    ReactImageSource source) {
+winrt::IAsyncOperation<winrt::IRandomAccessStream> ReactImage::GetImageMemoryStreamAsync(ReactImageSource source) {
   switch (source.sourceType) {
     case ImageSourceType::Download:
       co_return co_await GetImageStreamAsync(source);
@@ -223,7 +222,7 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
   const bool fromStream{
       source.sourceType == ImageSourceType::Download || source.sourceType == ImageSourceType::InlineData};
 
-  winrt::InMemoryRandomAccessStream memoryStream{nullptr};
+  winrt::IRandomAccessStream memoryStream{nullptr};
 
   // get weak reference before any co_await calls
   auto weak_this{get_weak()};
@@ -443,7 +442,7 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
   }
 }
 
-winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> GetImageStreamAsync(ReactImageSource source) {
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImageSource source) {
   try {
     co_await winrt::resume_background();
 
@@ -480,7 +479,7 @@ winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> GetImageStreamAsync(Re
   co_return nullptr;
 }
 
-winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> GetImageInlineDataAsync(ReactImageSource source) {
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageInlineDataAsync(ReactImageSource source) {
   size_t start = source.uri.find(',');
   if (start == std::string::npos || start + 1 > source.uri.length())
     co_return nullptr;

package/Microsoft.ReactNative/Views/Image/ReactImage.h

@@ -69,7 +69,7 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
  private:
   xaml::Media::Stretch ResizeModeToStretch();
   xaml::Media::Stretch ResizeModeToStretch(winrt::Windows::Foundation::Size size);
-  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::InMemoryRandomAccessStream>
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
   GetImageMemoryStreamAsync(ReactImageSource source);
   winrt::fire_and_forget SetBackground(bool fireLoadEndEvent);
 
@@ -91,8 +91,8 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
 };
 
 // Helper functions
-winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::InMemoryRandomAccessStream>
-GetImageStreamAsync(ReactImageSource source);
-winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::InMemoryRandomAccessStream>
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream> GetImageStreamAsync(
+    ReactImageSource source);
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
 GetImageInlineDataAsync(ReactImageSource source);
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Text/TextTransformParentVisitor.h

@@ -12,7 +12,7 @@ class TextTransformParentVisitor : public TextParentVisitor {
   using Super = TextParentVisitor;
 
  public:
-  TextTransform textTransform;
+  TextTransform textTransform{TextTransform::Undefined};
 
  protected:
   void VisitText(ShadowNodeBase *node) override;

package/Microsoft.ReactNative/Views/TextInputViewManager.cpp

@@ -513,6 +513,13 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
         m_hideCaret = propertyValue.AsBoolean();
         HideCaretIfNeeded();
       }
+    } else if (propertyName == "focusable") {
+      // parent class also sets isTabStop
+      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
+        control.IsEnabled(propertyValue.AsBoolean());
+      } else if (propertyValue.IsNull()) {
+        control.ClearValue(xaml::Controls::Control::IsEnabledProperty());
+      }
     } else if (propertyName == "secureTextEntry") {
       markDirty = true;
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
@@ -887,7 +894,13 @@ void TextInputViewManager::TransferProperties(const XamlView &oldView, const Xam
           xaml::Controls::TextBox::SelectionHighlightColorProperty(),
           xaml::Controls::PasswordBox::SelectionHighlightColorProperty());
       newView.as<xaml::Controls::PasswordBox>().Password(oldView.as<xaml::Controls::TextBox>().Text());
-      newView.as<xaml::Controls::PasswordBox>().IsEnabled(!oldView.as<xaml::Controls::TextBox>().IsReadOnly());
+      // Since both focasable/editable affect isEnabled for PasswordBox, if the oldView is enabled we still need to
+      // check isReadOnly
+      if (oldView.as<xaml::Controls::TextBox>().IsEnabled()) {
+        newView.as<xaml::Controls::PasswordBox>().IsEnabled(!oldView.as<xaml::Controls::TextBox>().IsReadOnly());
+      } else {
+        newView.as<xaml::Controls::PasswordBox>().IsEnabled(oldView.as<xaml::Controls::TextBox>().IsEnabled());
+      }
     } else {
       TransferProperty(
           oldView,
@@ -905,7 +918,13 @@ void TextInputViewManager::TransferProperties(const XamlView &oldView, const Xam
           xaml::Controls::PasswordBox::SelectionHighlightColorProperty(),
           xaml::Controls::TextBox::SelectionHighlightColorProperty());
       newView.as<xaml::Controls::TextBox>().Text(oldView.as<xaml::Controls::PasswordBox>().Password());
-      newView.as<xaml::Controls::TextBox>().IsReadOnly(!oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
+      // Since both focasable/editable affect isEnabled for PasswordBox, if the oldView is enabled we still need to
+      // check isReadOnly
+      if (oldView.as<xaml::Controls::PasswordBox>().IsEnabled()) {
+        newView.as<xaml::Controls::TextBox>().IsReadOnly(!oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
+      } else {
+        newView.as<xaml::Controls::TextBox>().IsEnabled(oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
+      }
     }
 
     TransferInputScope(oldView, newView, copyToPasswordBox);

package/Microsoft.ReactNative/Views/TextViewManager.cpp

@@ -67,7 +67,8 @@ class TextShadowNode final : public ShadowNodeBase {
     }
 
     auto addInline = true;
-    if (index == 0) {
+    // Only convert to fast text when exactly one child is attached to the root Text node
+    if (index == 0 && m_children.size() == 1) {
       auto run = childNode.GetView().try_as<winrt::Run>();
       if (run != nullptr) {
         m_firstChildNode = &child;
@@ -75,7 +76,8 @@ class TextShadowNode final : public ShadowNodeBase {
         textBlock.Text(run.Text());
         addInline = false;
       }
-    } else if (index == 1 && m_firstChildNode != nullptr) {
+    } else if (m_firstChildNode != nullptr) {
+      assert(m_children.size() == 2);
       auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
       textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
       Super::AddView(*m_firstChildNode, 0);
@@ -101,7 +103,8 @@ class TextShadowNode final : public ShadowNodeBase {
   }
 
   void RemoveChildAt(int64_t indexToRemove) override {
-    if (indexToRemove == 0 && m_firstChildNode) {
+    if (m_firstChildNode) {
+      assert(indexToRemove == 0);
       auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
       textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
       m_firstChildNode = nullptr;

package/Microsoft.ReactNative/Views/TouchEventHandler.cpp

@@ -240,7 +240,7 @@ TouchEventHandler::ReactPointer TouchEventHandler::CreateReactPointer(
   auto point = args.GetCurrentPoint(sourceElement);
   auto props = point.Properties();
 
-  ReactPointer pointer;
+  ReactPointer pointer{};
   pointer.target = tag;
   pointer.identifier = m_touchId++;
   pointer.pointerId = point.PointerId();

package/Microsoft.ReactNative/Views/ViewManagerBase.cpp

@@ -19,11 +19,14 @@
 #include <Utils/PropertyUtils.h>
 #include <Views/ExpressionAnimationStore.h>
 #include <Views/ShadowNodeBase.h>
+#include <cxxreact/SystraceSection.h>
 
 namespace winrt {
 using namespace xaml;
 }
 
+using namespace facebook::react;
+
 namespace Microsoft::ReactNative {
 
 static const std::unordered_map<std::string, PointerEventsKind> pointerEventsMap = {
@@ -248,7 +251,10 @@ void ViewManagerBase::UpdateProperties(
     }
   }
 
-  OnPropertiesUpdated(nodeToUpdate);
+  {
+    SystraceSection s("ViewManagerBase::OnPropertiesUpdated");
+    OnPropertiesUpdated(nodeToUpdate);
+  }
 }
 
 bool ViewManagerBase::UpdateProperty(

package/Microsoft.ReactNative/Views/ViewPanel.cpp

@@ -9,6 +9,7 @@
 #include <UI.Xaml.Media.h>
 #include <Utils/PropertyUtils.h>
 #include <Utils/ResourceBrushUtils.h>
+#include <cxxreact/SystraceSection.h>
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.UI.Xaml.Interop.h>
 
@@ -28,6 +29,8 @@ using namespace xaml::Media;
 using namespace Windows::Foundation;
 } // namespace winrt
 
+using namespace facebook::react;
+
 namespace winrt::Microsoft::ReactNative::implementation {
 
 const winrt::TypeName viewPanelTypeName{winrt::hstring{L"ViewPanel"}, winrt::TypeKind::Metadata};
@@ -227,6 +230,7 @@ void ViewPanel::ClipChildren(bool value) {
 }
 
 void ViewPanel::FinalizeProperties() {
+  SystraceSection s("ViewPanel::FinalizeProperties");
   if (!m_propertiesChanged)
     return;
 

package/Microsoft.ReactNative/Views/ViewViewManager.cpp

@@ -19,6 +19,7 @@
 #include <INativeUIManager.h>
 #include <IReactInstance.h>
 
+#include <cxxreact/SystraceSection.h>
 #include <inspectable.h>
 #include <unicode.h>
 #include <winrt/Windows.System.h>
@@ -30,6 +31,8 @@
 #include <winrt/Windows.Foundation.h>
 #endif
 
+using namespace facebook::react;
+
 namespace Microsoft::ReactNative {
 
 // ViewShadowNode
@@ -528,9 +531,11 @@ void ViewViewManager::TryUpdateView(
   //
   // 2. Transfer needed properties from old to new view
   //
-
-  // Transfer properties from old XamlView to the new one
-  TransferProperties(oldXamlView, newXamlView);
+  {
+    SystraceSection s("ViewViewManager::TransferProperties");
+    // Transfer properties from old XamlView to the new one
+    TransferProperties(oldXamlView, newXamlView);
+  }
 
   // Since we transferred properties to the new view we need to make the call to
   // finalize

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

@@ -56,6 +56,8 @@ namespace Microsoft.ReactNative
     CountStates
   };
 
+  // When adding a new numeric value, make sure to increment 'numericValuesCount' in FrameworkElementViewManager
+  // updateProperties depends on Min, Max, Now values being 0-2 for indexing. Be careful not to break that logic when adding new values.
   enum AccessibilityValue
   {
     Min = 0,

package/Microsoft.ReactNative/microsoft.reactnative.def

@@ -1,3 +1,6 @@
-EXPORTS
+EXPORTS
 DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
 DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE
+
+RNCoreAppStart
+RNCoreAppStartFromConfigJson

package/Microsoft.ReactNative.Cxx/AppModelHelpers.h

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+// AppModel helpers
+
+#include <appmodel.h>
+
+namespace Microsoft::ReactNative {
+
+inline bool HasPackageIdentity() noexcept {
+  uint32_t length{0};
+  const bool isPackagedApp = GetCurrentPackageFullName(&length, nullptr) != APPMODEL_ERROR_NO_PACKAGE;
+  return isPackagedApp;
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative.Cxx/CoreApp.h

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+struct RNCoreApp {
+  /// default value: L"index.windows"
+  wchar_t const *jsBundleFile;
+  /// default value: L"ms-appx:///Bundle/"
+  wchar_t const *bundleRootPath;
+  /// Provide the name of your React component here
+  wchar_t const *componentName;
+
+  /// default value: true
+  bool useWebDebugger;
+  /// default value: true
+  bool useFastRefresh;
+  /// default value: true
+  bool useDeveloperSupport;
+  /// default value: false
+  bool useDirectDebugger;
+  /// default value: true
+  bool requestInlineSourceMap;
+
+  /// default value: false
+  bool enableDefaultCrashHandler;
+  /// default value: 9229
+  unsigned short debuggerPort;
+  /// default value: 8081
+  unsigned short sourceBundlePort;
+  /// default value: L"localhost"
+  wchar_t const *sourceBundleHost;
+
+  /// default value: "chakra", possible values: "chakra", "hermes"
+  wchar_t const *jsEngine;
+
+  /// default value: nullptr
+  wchar_t const *viewName;
+
+  void *resourcesAbi;
+  /// Provides the launch arguments back to the CoreApp callback
+  wchar_t const *args;
+  /// Allocate with CoTaskMemAlloc, will be freed by the framework
+  void **packageProvidersAbi;
+  unsigned char packageProvidersAbiCount;
+  void *propertiesAbi;
+};
+
+#ifdef __cplusplus
+#define NORETURN [[noreturn]]
+#else
+#define NORETURN _Noreturn
+#endif
+
+typedef void(__cdecl *RNCoreAppCallback)(RNCoreApp *, void *);
+
+extern "C" NORETURN void __cdecl RNCoreAppStart(RNCoreAppCallback launched, void *data);
+extern "C" NORETURN void __cdecl RNCoreAppStartFromConfigJson(
+    wchar_t const *configJson,
+    RNCoreAppCallback launched,
+    void *data);

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

@@ -263,6 +263,13 @@ Runtime::PointerValue *JsiAbiRuntime::cloneSymbol(const Runtime::PointerValue *p
   throw;
 }
 
+Runtime::PointerValue *JsiAbiRuntime::cloneBigInt(const Runtime::PointerValue *pv) try {
+  return new BigIntPointerValue{make_weak(m_runtime), m_runtime.CloneBigInt(AsJsiBigIntRef(pv))};
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+
 Runtime::PointerValue *JsiAbiRuntime::cloneString(const Runtime::PointerValue *pv) try {
   return new StringPointerValue{make_weak(m_runtime), m_runtime.CloneString(AsJsiStringRef(pv))};
 } catch (hresult_error const &) {
@@ -623,6 +630,13 @@ bool JsiAbiRuntime::strictEquals(const Symbol &a, const Symbol &b) const try {
   throw;
 }
 
+bool JsiAbiRuntime::strictEquals(const BigInt &a, const BigInt &b) const try {
+  return m_runtime.BigIntStrictEquals(AsJsiBigIntRef(a), AsJsiBigIntRef(b));
+} catch (hresult_error const &) {
+  RethrowJsiError();
+  throw;
+}
+
 bool JsiAbiRuntime::strictEquals(const String &a, const String &b) const try {
   return m_runtime.StringStrictEquals(AsJsiStringRef(a), AsJsiStringRef(b));
 } catch (hresult_error const &) {
@@ -686,6 +700,10 @@ void JsiAbiRuntime::SetJsiError(std::exception const &nativeException) noexcept
   return SymbolPointerValue::GetData(pv);
 }
 
+/*static*/ JsiBigIntRef const &JsiAbiRuntime::AsJsiBigIntRef(PointerValue const *pv) noexcept {
+  return BigIntPointerValue::GetData(pv);
+}
+
 /*static*/ JsiStringRef const &JsiAbiRuntime::AsJsiStringRef(PointerValue const *pv) noexcept {
   return StringPointerValue::GetData(pv);
 }
@@ -702,6 +720,10 @@ void JsiAbiRuntime::SetJsiError(std::exception const &nativeException) noexcept
   return SymbolPointerValue::GetData(getPointerValue(symbol));
 }
 
+/*static*/ JsiBigIntRef const &JsiAbiRuntime::AsJsiBigIntRef(BigInt const &bigInt) noexcept {
+  return BigIntPointerValue::GetData(getPointerValue(bigInt));
+}
+
 /*static*/ JsiStringRef const &JsiAbiRuntime::AsJsiStringRef(String const &str) noexcept {
   return StringPointerValue::GetData(getPointerValue(str));
 }
@@ -722,9 +744,12 @@ void JsiAbiRuntime::SetJsiError(std::exception const &nativeException) noexcept
   // We assume that the JsiValueRef and Value have the same layout.
   auto valuePtr = reinterpret_cast<JsiValueRef const *>(&value);
   // Fix up the data part
+  // TODO: JSIVALUECONVERSION - Need to fix JSI kind mapping
   switch (valuePtr->Kind) {
     case JsiValueKind::Symbol:
       return {valuePtr->Kind, SymbolPointerValue::GetData(getPointerValue(value)).Data};
+    case JsiValueKind::BigInt:
+      return {valuePtr->Kind, BigIntPointerValue::GetData(getPointerValue(value)).Data};
     case JsiValueKind::String:
       return {valuePtr->Kind, StringPointerValue::GetData(getPointerValue(value)).Data};
     case JsiValueKind::Object:
@@ -747,9 +772,12 @@ void JsiAbiRuntime::SetJsiError(std::exception const &nativeException) noexcept
   // data alive. Thus, we must detach the value.
   // We assume that the JsiValueRef and Value have the same layout.
   auto valuePtr = reinterpret_cast<JsiValueRef *>(&value);
+  // TODO: JSIVALUECONVERSION - Need to fix JSI kind mapping
   switch (valuePtr->Kind) {
     case JsiValueKind::Symbol:
       return {valuePtr->Kind, SymbolPointerValue::Detach(getPointerValue(value)).Data};
+    case JsiValueKind::BigInt:
+      return {valuePtr->Kind, BigIntPointerValue::Detach(getPointerValue(value)).Data};
     case JsiValueKind::String:
       return {valuePtr->Kind, StringPointerValue::Detach(getPointerValue(value)).Data};
     case JsiValueKind::Object:
@@ -763,6 +791,10 @@ Runtime::PointerValue *JsiAbiRuntime::MakeSymbolValue(JsiSymbolRef &&symbol) con
   return new SymbolPointerValue{make_weak(m_runtime), std::move(symbol)};
 }
 
+Runtime::PointerValue *JsiAbiRuntime::MakeBigIntValue(JsiBigIntRef &&bigInt) const noexcept {
+  return new BigIntPointerValue{make_weak(m_runtime), std::move(bigInt)};
+}
+
 Runtime::PointerValue *JsiAbiRuntime::MakeStringValue(JsiStringRef &&str) const noexcept {
   return new StringPointerValue{make_weak(m_runtime), std::move(str)};
 }
@@ -779,6 +811,10 @@ Symbol JsiAbiRuntime::MakeSymbol(JsiSymbolRef &&symbol) const noexcept {
   return make<Symbol>(MakeSymbolValue(std::move(symbol)));
 }
 
+BigInt JsiAbiRuntime::MakeBigInt(JsiBigIntRef &&bigInt) const noexcept {
+  return make<BigInt>(MakeBigIntValue(std::move(bigInt)));
+}
+
 String JsiAbiRuntime::MakeString(JsiStringRef &&str) const noexcept {
   return make<String>(MakeStringValue(std::move(str)));
 }
@@ -815,6 +851,8 @@ Value JsiAbiRuntime::MakeValue(JsiValueRef &&value) const noexcept {
       return Value(*reinterpret_cast<double *>(&value.Data));
     case JsiValueKind::Symbol:
       return Value(MakeSymbol(JsiSymbolRef{value.Data}));
+    case JsiValueKind::BigInt:
+      return Value(MakeBigInt(JsiBigIntRef{value.Data}));
     case JsiValueKind::String:
       return Value(MakeString(JsiStringRef{value.Data}));
     case JsiValueKind::Object:
@@ -861,6 +899,32 @@ void JsiAbiRuntime::SymbolPointerValue::invalidate() {
   return {std::exchange(static_cast<DataPointerValue *>(const_cast<PointerValue *>(pv))->m_data, 0)};
 }
 
+//===========================================================================
+// JsiAbiRuntime::BigIntPointerValue implementation
+//===========================================================================
+
+JsiAbiRuntime::BigIntPointerValue::BigIntPointerValue(
+    winrt::weak_ref<JsiRuntime> &&weakRuntime,
+    JsiBigIntRef &&bigInt) noexcept
+    : DataPointerValue{std::move(weakRuntime), std::exchange(bigInt.Data, 0)} {}
+
+void JsiAbiRuntime::BigIntPointerValue::invalidate() {
+  if (m_data) {
+    if (auto runtime = m_weakRuntime.get()) {
+      m_weakRuntime = nullptr;
+      runtime.ReleaseBigInt({m_data});
+    }
+  }
+}
+
+/*static*/ JsiBigIntRef const &JsiAbiRuntime::BigIntPointerValue::GetData(PointerValue const *pv) noexcept {
+  return *reinterpret_cast<JsiBigIntRef const *>(&static_cast<DataPointerValue const *>(pv)->m_data);
+}
+
+/*static*/ JsiBigIntRef JsiAbiRuntime::BigIntPointerValue::Detach(PointerValue const *pv) noexcept {
+  return {std::exchange(static_cast<DataPointerValue *>(const_cast<PointerValue *>(pv))->m_data, 0)};
+}
+
 //===========================================================================
 // JsiAbiRuntime::StringPointerValue implementation
 //===========================================================================
@@ -964,6 +1028,7 @@ JsiAbiRuntime::ValueRef::InitValueRef(JsiValueRef const &data, Value *value, Sto
   // We assume that the JsiValueRef and Value have the same layout.
   auto valueAsDataPtr = reinterpret_cast<JsiValueRef *>(value);
   valueAsDataPtr->Kind = data.Kind;
+  // TODO: JSIVALUECONVERSION - Need to fix JSI kind mapping
   switch (valueAsDataPtr->Kind) {
     case JsiValueKind::Symbol:
     case JsiValueKind::String: