react-native-windows 0.66.23 → 0.66.24

package/CHANGELOG.json

@@ -2,7 +2,28 @@
   "name": "react-native-windows",
   "entries": [
     {
-      "date": "Fri, 17 Jun 2022 17:40:41 GMT",
+      "date": "Thu, 23 Jun 2022 18:48:52 GMT",
+      "tag": "react-native-windows_v0.66.24",
+      "version": "0.66.24",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Stop compiling yoga.cpp with /fp:strict. Doing so caused layout issues if Yoga code ran with the processor's rounding mode set to round down, due to NAN being defined in math.h as: ``` (float)(INFINITY * 0.0f) ``` Which macro-expands to: ``` (float)(((float)(1e+300 * 1e+300)) * 0.0f) ``` Which evaluates as follows: ``` (float)(((float)(inf.double)) * 0.0f) (float)(FLT_MAX * 0.0f) // Casting an infinite double to a float yields                         // FLT_MAX! (float)0.0f ```",
+            "author": "hpratt@microsoft.com",
+            "commit": "f13c49abc467b74828e3b93b3dd3d07c1c6658ed",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Fix ExecuteJsi on instance shutdown",
+            "author": "vmorozov@microsoft.com",
+            "commit": "eb2764814113e3e64735e9d7503b8e4af98bb059",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Fri, 17 Jun 2022 17:40:57 GMT",
       "tag": "react-native-windows_v0.66.23",
       "version": "0.66.23",
       "comments": {

package/CHANGELOG.md

@@ -1,17 +1,26 @@
 # Change Log - react-native-windows
 
-This log was last generated on Fri, 17 Jun 2022 17:40:41 GMT and should not be manually modified.
+This log was last generated on Thu, 23 Jun 2022 18:48:52 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## 0.66.23
+## 0.66.24
 
-Fri, 17 Jun 2022 17:40:41 GMT
+Thu, 23 Jun 2022 18:48:52 GMT
 
 ### Patches
 
-- Fix use of [[maybe_unused]] attribute (vmorozov@microsoft.com)
+- Stop compiling yoga.cpp with /fp:strict. Doing so caused layout issues if Yoga code ran with the processor's rounding mode set to round down, due to NAN being defined in math.h as: ``` (float)(INFINITY * 0.0f) ``` Which macro-expands to: ``` (float)(((float)(1e+300 * 1e+300)) * 0.0f) ``` Which evaluates as follows: ``` (float)(((float)(inf.double)) * 0.0f) (float)(FLT_MAX * 0.0f) // Casting an infinite double to a float yields                         // FLT_MAX! (float)0.0f ``` (hpratt@microsoft.com)
+- Fix ExecuteJsi on instance shutdown (vmorozov@microsoft.com)
 
+## 0.66.23
+
+Fri, 17 Jun 2022 17:40:57 GMT
+
+### Patches
+
+- Fix use of [[maybe_unused]] attribute (vmorozov@microsoft.com)
+
 ## 0.66.22
 
 Thu, 09 Jun 2022 04:18:35 GMT

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

@@ -10,16 +10,19 @@ extern "C" IMAGE_DOS_HEADER __ImageBase;
 
 namespace winrt::Microsoft::ReactNative {
 
-// Get JSI Runtime from the current JS dispatcher thread.
-// If it is not found, then create it and store it in the context.Properties().
-// Make sure that the JSI runtime holder is removed when the instance is unloaded.
-facebook::jsi::Runtime &GetOrCreateContextRuntime(ReactContext const &context) noexcept {
+// Try to get JSI Runtime for the current JS dispatcher thread.
+// If it is not found, then create it based on context JSI runtime and store it in the context.Properties().
+// The function returns nullptr if the current context does not have JSI runtime.
+// It makes sure that the JSI runtime holder is removed when the instance is unloaded.
+facebook::jsi::Runtime *TryGetOrCreateContextRuntime(ReactContext const &context) noexcept {
   ReactDispatcher jsDispatcher = context.JSDispatcher();
   VerifyElseCrashSz(jsDispatcher.HasThreadAccess(), "Must be in JS thread");
 
   // The JSI runtime is not available if we do Web debugging when JS is running in web browser.
   JsiRuntime abiJsiRuntime = context.Handle().JSRuntime().as<JsiRuntime>();
-  VerifyElseCrashSz(abiJsiRuntime, "JSI runtime is not available");
+  if (!abiJsiRuntime) {
+    return nullptr;
+  }
 
   // See if the JSI runtime was previously created.
   JsiAbiRuntime *runtime = JsiAbiRuntime::GetFromJsiRuntime(abiJsiRuntime);
@@ -51,6 +54,15 @@ facebook::jsi::Runtime &GetOrCreateContextRuntime(ReactContext const &context) n
         });
   }
 
+  return runtime;
+}
+
+// Calls TryGetOrCreateContextRuntime to get JSI runtime.
+// It crashes when TryGetOrCreateContextRuntime returns null.
+// Note: deprecated in favor of TryGetOrCreateContextRuntime.
+[[deprecated]] facebook::jsi::Runtime &GetOrCreateContextRuntime(ReactContext const &context) noexcept {
+  facebook::jsi::Runtime *runtime = TryGetOrCreateContextRuntime(context);
+  VerifyElseCrashSz(runtime, "JSI runtime is not available");
   return *runtime;
 }
 

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

@@ -7,26 +7,55 @@
 
 #include "../ReactContext.h"
 #include "JsiAbiApi.h"
+#include "ReactPromise.h"
 
 namespace winrt::Microsoft::ReactNative {
 
-// Get JSI Runtime from the current JS dispatcher thread.
-// If it is not found, then create it and store it in the context.Properties().
-// Make sure that the JSI runtime holder is removed when the instance is unloaded.
-facebook::jsi::Runtime &GetOrCreateContextRuntime(ReactContext const &context) noexcept;
+// Try to get JSI Runtime for the current JS dispatcher thread.
+// If it is not found, then create it based on context JSI runtime and store it in the context.Properties().
+// The function returns nullptr if the current context does not have JSI runtime.
+// It makes sure that the JSI runtime holder is removed when the instance is unloaded.
+facebook::jsi::Runtime *TryGetOrCreateContextRuntime(ReactContext const &context) noexcept;
+
+// Calls TryGetOrCreateContextRuntime to get JSI runtime.
+// It crashes when TryGetOrCreateContextRuntime returns null.
+// Note: deprecated in favor of TryGetOrCreateContextRuntime.
+[[deprecated]] facebook::jsi::Runtime &GetOrCreateContextRuntime(ReactContext const &context) noexcept;
 
 // Call provided lambda with the facebook::jsi::Runtime& parameter.
 // For example: ExecuteJsi(context, [](facebook::jsi::Runtime& runtime){...})
 // The code is executed synchronously if it is already in JSDispatcher, or asynchronously otherwise.
 template <class TCodeWithRuntime>
-void ExecuteJsi(ReactContext const &context, TCodeWithRuntime const &code) {
+void ExecuteJsi(ReactContext const &context, TCodeWithRuntime const &code, ReactPromise<void> *callStatus = nullptr) {
   ReactDispatcher jsDispatcher = context.JSDispatcher();
+  auto callCode = [](ReactContext const &context, TCodeWithRuntime const &code, ReactPromise<void> *callStatus) {
+    facebook::jsi::Runtime *runtime = TryGetOrCreateContextRuntime(context);
+    if (runtime) {
+      code(*runtime);
+    }
+
+    // Report status of the call
+    if (callStatus) {
+      if (runtime) {
+        callStatus->Resolve();
+      } else {
+        callStatus->Reject("No JSI runtime");
+      }
+    }
+  };
+
   if (jsDispatcher.HasThreadAccess()) {
     // Execute immediately if we are in JS thread.
-    code(GetOrCreateContextRuntime(context));
+    callCode(context, code, callStatus);
   } else {
     // Otherwise, schedule work in JS thread.
-    jsDispatcher.Post([context, code]() noexcept { code(GetOrCreateContextRuntime(context)); });
+    jsDispatcher.Post([callCode,
+                       context,
+                       code,
+                       callStatus = callStatus ? std::make_unique<ReactPromise<void>>(*callStatus)
+                                               : std::unique_ptr<ReactPromise<void>>(nullptr)]() noexcept {
+      callCode(context, code, callStatus.get());
+    });
   }
 }
 

package/Microsoft.ReactNative.Cxx/ReactPromise.cpp

@@ -6,7 +6,6 @@
 
 #include "pch.h"
 #include "ReactPromise.h"
-#include "JSValueWriter.h"
 
 namespace winrt::Microsoft::ReactNative {
 
@@ -105,6 +104,27 @@ bool ReactPromiseBase::TrySetState(State newState) const noexcept {
   return false;
 }
 
+/*static*/ MethodResultCallback ReactPromiseBase::GetRejectResultCallback(
+    std::function<void(ReactError const &)> const &reject) noexcept {
+  return [reject](IJSValueWriter const &outputWriter) noexcept {
+    winrt::com_ptr<JSValueTreeWriter> writer = outputWriter.as<JSValueTreeWriter>();
+    JSValue jsValue = writer->TakeValue();
+    ReactError err{};
+    err.Code = jsValue.AsArray()[0].AsObject()[ErrorMapKeyCode].AsString();
+    err.Message = jsValue.AsArray()[0].AsObject()[ErrorMapKeyMessage].AsString();
+    err.UserInfo = jsValue.AsArray()[0].AsObject()[ErrorMapKeyUserInfo].AsObject().Copy();
+    reject(err);
+  };
+}
+
+ReactPromise<void>::ReactPromise(
+    std::function<void()> const &resolve,
+    std::function<void(ReactError const &)> const &reject) noexcept
+    : ReactPromiseBase(
+          winrt::make<JSValueTreeWriter>(),
+          [resolve](IJSValueWriter const & /*outputWriter*/) noexcept { resolve(); },
+          GetRejectResultCallback(reject)) {}
+
 // Successfully resolve the ReactPromise<void>.
 void ReactPromise<void>::Resolve() const noexcept {
   if (TrySetState(State::Resolved) && m_resolve) {

package/Microsoft.ReactNative.Cxx/ReactPromise.h

@@ -5,6 +5,11 @@
 // vnext/Microsoft.ReactNative.Cxx/README.md
 
 #pragma once
+#include <functional>
+#include "JSValueReader.h"
+#include "JSValueTreeReader.h"
+#include "JSValueTreeWriter.h"
+#include "JSValueWriter.h"
 #include "ReactError.h"
 #include "winrt/Microsoft.ReactNative.h"
 
@@ -35,6 +40,7 @@ struct ReactPromiseBase {
 
  protected:
   bool TrySetState(State newState) const noexcept;
+  static MethodResultCallback GetRejectResultCallback(std::function<void(ReactError const &)> const &reject) noexcept;
 
  protected:
   const std::shared_ptr<std::atomic<State>> m_state;
@@ -47,6 +53,10 @@ template <class T>
 struct ReactPromise : ReactPromiseBase {
   using ReactPromiseBase::ReactPromiseBase;
 
+  ReactPromise(
+      std::function<void(T const &)> const &resolve,
+      std::function<void(ReactError const &)> const &reject) noexcept;
+
   // Successfully resolve the IReactPromise with an optional value.
   void Resolve(T const &value) const noexcept;
 };
@@ -55,10 +65,27 @@ template <>
 struct ReactPromise<void> : ReactPromiseBase {
   using ReactPromiseBase::ReactPromiseBase;
 
+  ReactPromise(std::function<void()> const &resolve, std::function<void(ReactError const &)> const &reject) noexcept;
+
   // Successfully resolve the IReactPromise with an optional value.
   void Resolve() const noexcept;
 };
 
+template <class T>
+ReactPromise<T>::ReactPromise(
+    std::function<void(T const &)> const &resolve,
+    std::function<void(ReactError const &)> const &reject) noexcept
+    : ReactPromiseBase(
+          winrt::make<JSValueTreeWriter>(),
+          [resolve](IJSValueWriter const &outputWriter) noexcept {
+            winrt::com_ptr<JSValueTreeWriter> writer = outputWriter.as<JSValueTreeWriter>();
+            auto reader = winrt::make<JSValueTreeReader>(writer->TakeValue());
+            T result{};
+            ReadArgs(reader, result);
+            resolve(result);
+          },
+          GetRejectResultCallback(reject)) {}
+
 // Successfully resolve the ReactPromise with an optional value.
 template <class T>
 void ReactPromise<T>::Resolve(T const &value) const noexcept {

package/Microsoft.ReactNative.Cxx/TurboModuleProvider.h

@@ -23,7 +23,7 @@ void AddTurboModuleProvider(IReactPackageBuilder const &packageBuilder, std::wst
         IJsiHostObject abiTurboModule{nullptr};
         // We expect the initializer to be called immediately for TurboModules
         moduleBuilder.AddInitializer([&abiTurboModule](IReactContext const &context) mutable {
-          GetOrCreateContextRuntime(ReactContext{context}); // Ensure the JSI runtime is created.
+          TryGetOrCreateContextRuntime(ReactContext{context}); // Ensure the JSI runtime is created.
           auto callInvoker = MakeAbiCallInvoker(context.JSDispatcher());
           auto turboModule = std::make_shared<TTurboModule>(callInvoker);
           abiTurboModule = winrt::make<JsiHostObjectWrapper>(std::move(turboModule));

package/ReactCommon/ReactCommon.vcxproj

@@ -72,10 +72,6 @@
       <DisableSpecificWarnings>4715;4251;4800;4804;4305;4722;%(DisableSpecificWarnings)</DisableSpecificWarnings>
       <PreprocessToFile>false</PreprocessToFile>
       <ForcedIncludeFiles>pch.h;%(ForcedIncludeFiles)</ForcedIncludeFiles>
-      <!--
-        Using Strict FloatingPointModel on x64 to workaround a compiler issue, See https://github.com/microsoft/react-native-windows/issues/4122
-      -->
-      <FloatingPointModel Condition="'$(Platform)' == 'x64'">Strict</FloatingPointModel>
     </ClCompile>
     <Link>
       <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/CompactValue.h

@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+
+#ifdef __cpp_lib_bit_cast
+#include <bit>
+#endif
+#include "YGValue.h"
+#include "YGMacros.h"
+#include <cmath>
+#include <cstdint>
+#include <limits>
+
+static_assert(
+    std::numeric_limits<float>::is_iec559,
+    "facebook::yoga::detail::CompactValue only works with IEEE754 floats");
+
+#ifdef YOGA_COMPACT_VALUE_TEST
+#define VISIBLE_FOR_TESTING public:
+#else
+#define VISIBLE_FOR_TESTING private:
+#endif
+
+namespace facebook {
+namespace yoga {
+namespace detail {
+
+// This class stores YGValue in 32 bits.
+// - The value does not matter for Undefined and Auto. NaNs are used for their
+//   representation.
+// - To differentiate between Point and Percent, one exponent bit is used.
+//   Supported the range [0x40, 0xbf] (0xbf is inclusive for point, but
+//   exclusive for percent).
+// - Value ranges:
+//   points:  1.08420217e-19f to 36893485948395847680
+//            0x00000000         0x3fffffff
+//   percent: 1.08420217e-19f to 18446742974197923840
+//            0x40000000         0x7f7fffff
+// - Zero is supported, negative zero is not
+// - values outside of the representable range are clamped
+class YOGA_EXPORT CompactValue {
+  friend constexpr bool operator==(CompactValue, CompactValue) noexcept;
+
+ public:
+  static constexpr auto LOWER_BOUND = 1.08420217e-19f;
+  static constexpr auto UPPER_BOUND_POINT = 36893485948395847680.0f;
+  static constexpr auto UPPER_BOUND_PERCENT = 18446742974197923840.0f;
+
+  template <YGUnit Unit>
+  static CompactValue of(float value) noexcept {
+    if (value == 0.0f || (value < LOWER_BOUND && value > -LOWER_BOUND)) {
+      constexpr auto zero =
+        Unit == YGUnitPercent ? ZERO_BITS_PERCENT : ZERO_BITS_POINT;
+      return {zero};
+    }
+
+    constexpr auto upperBound = Unit == YGUnitPercent ? UPPER_BOUND_PERCENT : UPPER_BOUND_POINT;
+    if (value > upperBound || value < -upperBound) {
+      value = copysignf(upperBound, value);
+    }
+
+    uint32_t unitBit = Unit == YGUnitPercent ? PERCENT_BIT : 0;
+    auto data = asU32(value);
+    data -= BIAS;
+    data |= unitBit;
+    return {data};
+  }
+
+  template <YGUnit Unit>
+  static CompactValue ofMaybe(float value) noexcept {
+    return std::isnan(value) || std::isinf(value) ? ofUndefined() : of<Unit>(value);
+  }
+
+  static constexpr CompactValue ofZero() noexcept {
+    return CompactValue{ZERO_BITS_POINT};
+  }
+
+  static constexpr CompactValue ofUndefined() noexcept {
+    return CompactValue{};
+  }
+
+  static constexpr CompactValue ofAuto() noexcept {
+    return CompactValue{AUTO_BITS};
+  }
+
+  constexpr CompactValue() noexcept : repr_(0x7FC00000) {}
+
+  CompactValue(const YGValue &x) noexcept : repr_(uint32_t{0}) {
+    switch (x.unit) {
+      case YGUnitUndefined:
+        *this = ofUndefined();
+        break;
+      case YGUnitAuto:
+        *this = ofAuto();
+        break;
+      case YGUnitPoint:
+        *this = of<YGUnitPoint>(x.value);
+        break;
+      case YGUnitPercent:
+        *this = of<YGUnitPercent>(x.value);
+        break;
+    }
+  }
+
+  operator YGValue() const noexcept {
+    switch (repr_) {
+      case AUTO_BITS:
+        return YGValueAuto;
+      case ZERO_BITS_POINT:
+        return YGValue{0.0f, YGUnitPoint};
+      case ZERO_BITS_PERCENT:
+        return YGValue{0.0f, YGUnitPercent};
+    }
+
+    if (std::isnan(asFloat(repr_))) {
+      return YGValueUndefined;
+    }
+
+    auto data = repr_;
+    data &= ~PERCENT_BIT;
+    data += BIAS;
+
+    return YGValue{asFloat(data), repr_ & 0x40000000 ? YGUnitPercent : YGUnitPoint};
+  }
+
+  bool isUndefined() const noexcept {
+    return (repr_ != AUTO_BITS && repr_ != ZERO_BITS_POINT && repr_ != ZERO_BITS_PERCENT && std::isnan(asFloat(repr_)));
+  }
+
+  bool isAuto() const noexcept {
+    return repr_ == AUTO_BITS;
+  }
+
+ private:
+  uint32_t repr_;
+  
+  static constexpr uint32_t BIAS = 0x20000000;
+  static constexpr uint32_t PERCENT_BIT = 0x40000000;
+
+  // these are signaling NaNs with specific bit pattern as payload they will be
+  // silenced whenever going through an FPU operation on ARM + x86
+  static constexpr uint32_t AUTO_BITS = 0x7faaaaaa;
+  static constexpr uint32_t ZERO_BITS_POINT = 0x7f8f0f0f;
+  static constexpr uint32_t ZERO_BITS_PERCENT = 0x7f80f0f0;
+
+  constexpr CompactValue(uint32_t data) noexcept : repr_(data) {}
+
+  VISIBLE_FOR_TESTING uint32_t repr() {
+    return repr_;
+  }
+
+  static uint32_t asU32(float f) {
+#ifdef __cpp_lib_bit_cast
+    return std::bit_cast<uint32_t>(f);
+#else
+    uint32_t u;
+    static_assert(sizeof(u) == sizeof(f));
+    std::memcpy(&u, &f, sizeof(f));
+    return u;
+#endif
+  }
+
+  static float asFloat(uint32_t u) {
+#ifdef __cpp_lib_bit_cast
+    return std::bit_cast<float>(data);
+#else
+    float f;
+    static_assert(sizeof(f) == sizeof(u));
+    std::memcpy(&f, &u, sizeof(u));
+    return f;
+#endif
+  }
+};
+
+
+template <>
+CompactValue CompactValue::of<YGUnitUndefined>(float) noexcept = delete;
+template <>
+CompactValue CompactValue::of<YGUnitAuto>(float) noexcept = delete;
+template <>
+CompactValue CompactValue::ofMaybe<YGUnitUndefined>(float) noexcept = delete;
+template <>
+CompactValue CompactValue::ofMaybe<YGUnitAuto>(float) noexcept = delete;
+
+constexpr bool operator==(CompactValue a, CompactValue b) noexcept {
+  return a.repr_ == b.repr_;
+}
+
+constexpr bool operator!=(CompactValue a, CompactValue b) noexcept {
+  return !(a == b);
+}
+
+} // namespace detail
+} // namespace yoga
+} // namespace facebook
+
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.66.23",
+  "version": "0.66.24",
   "license": "MIT",
   "repository": {
     "type": "git",

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/YGValue.h

@@ -1,94 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <math.h>
-#include "YGEnums.h"
-#include "YGMacros.h"
-
-#if defined(_MSC_VER) && defined(__clang__)
-#define COMPILING_WITH_CLANG_ON_WINDOWS
-#endif
-#if defined(COMPILING_WITH_CLANG_ON_WINDOWS)
-#include <limits>
-constexpr float YGUndefined = std::numeric_limits<float>::quiet_NaN();
-#else
-YG_EXTERN_C_BEGIN
-
-#if defined(_MSC_VER)
-#define YGUndefined __builtin_nanf("0")
-#else
-#define YGUndefined NAN
-#endif
-
-#endif
-
-typedef struct YGValue {
-  float value;
-  YGUnit unit;
-} YGValue;
-
-YOGA_EXPORT extern const YGValue YGValueAuto;
-YOGA_EXPORT extern const YGValue YGValueUndefined;
-YOGA_EXPORT extern const YGValue YGValueZero;
-
-#if !defined(COMPILING_WITH_CLANG_ON_WINDOWS)
-YG_EXTERN_C_END
-#endif
-#undef COMPILING_WITH_CLANG_ON_WINDOWS
-
-#ifdef __cplusplus
-
-inline bool operator==(const YGValue& lhs, const YGValue& rhs) {
-  if (lhs.unit != rhs.unit) {
-    return false;
-  }
-
-  switch (lhs.unit) {
-    case YGUnitUndefined:
-    case YGUnitAuto:
-      return true;
-    case YGUnitPoint:
-    case YGUnitPercent:
-      return lhs.value == rhs.value;
-  }
-
-  return false;
-}
-
-inline bool operator!=(const YGValue& lhs, const YGValue& rhs) {
-  return !(lhs == rhs);
-}
-
-inline YGValue operator-(const YGValue& value) {
-  return {-value.value, value.unit};
-}
-
-namespace facebook {
-namespace yoga {
-namespace literals {
-
-inline YGValue operator"" _pt(long double value) {
-  return YGValue{static_cast<float>(value), YGUnitPoint};
-}
-inline YGValue operator"" _pt(unsigned long long value) {
-  return operator"" _pt(static_cast<long double>(value));
-}
-
-inline YGValue operator"" _percent(long double value) {
-  return YGValue{static_cast<float>(value), YGUnitPercent};
-}
-inline YGValue operator"" _percent(unsigned long long value) {
-  return operator"" _percent(static_cast<long double>(value));
-}
-
-} // namespace literals
-} // namespace yoga
-} // namespace facebook
-
-#endif