react-native-windows 0.81.0 → 0.81.2

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/HighResTimeStamp.h

@@ -0,0 +1,41 @@
+/*
+ * 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
+
+#include <react/bridging/Base.h>
+#include <react/timing/primitives.h>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<HighResTimeStamp> {
+  static HighResTimeStamp fromJs(
+      jsi::Runtime& /*rt*/,
+      const jsi::Value& jsiValue) {
+    return HighResTimeStamp::fromDOMHighResTimeStamp(jsiValue.asNumber());
+  }
+
+  static double toJs(jsi::Runtime& /*rt*/, const HighResTimeStamp& value) {
+    return value.toDOMHighResTimeStamp();
+  }
+};
+
+template <>
+struct Bridging<HighResDuration> {
+  static HighResDuration fromJs(
+      jsi::Runtime& /*rt*/,
+      const jsi::Value& jsiValue) {
+    return HighResDuration::fromDOMHighResTimeStamp(jsiValue.asNumber());
+  }
+
+  static double toJs(jsi::Runtime& /*rt*/, const HighResDuration& value) {
+    return value.toDOMHighResTimeStamp();
+  }
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/timing/primitives.h

@@ -0,0 +1,298 @@
+/*
+ * 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
+
+#include <chrono>
+
+namespace facebook::react {
+
+class HighResDuration;
+class HighResTimeStamp;
+
+/*
+ * A class representing a duration of time with high precision.
+ *
+ * @see __docs__/README.md for more information.
+ */
+class HighResDuration {
+  friend class HighResTimeStamp;
+  friend constexpr HighResDuration operator-(
+      const HighResTimeStamp& lhs,
+      const HighResTimeStamp& rhs);
+  friend constexpr HighResTimeStamp operator+(
+      const HighResTimeStamp& lhs,
+      const HighResDuration& rhs);
+  friend constexpr HighResTimeStamp operator-(
+      const HighResTimeStamp& lhs,
+      const HighResDuration& rhs);
+
+ public:
+  constexpr HighResDuration()
+      : chronoDuration_(std::chrono::steady_clock::duration()) {}
+
+  static constexpr HighResDuration zero() {
+    return HighResDuration(std::chrono::steady_clock::duration::zero());
+  }
+
+  static constexpr HighResDuration fromChrono(
+      std::chrono::steady_clock::duration chronoDuration) {
+    return HighResDuration(chronoDuration);
+  }
+
+  static constexpr HighResDuration fromNanoseconds(int64_t units) {
+    return HighResDuration(std::chrono::nanoseconds(units));
+  }
+
+  static constexpr HighResDuration fromMilliseconds(int64_t units) {
+    return HighResDuration(std::chrono::milliseconds(units));
+  }
+
+  constexpr int64_t toNanoseconds() const {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(chronoDuration_)
+        .count();
+  }
+
+  // @see https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp
+  static constexpr HighResDuration fromDOMHighResTimeStamp(double units) {
+    auto nanoseconds = static_cast<int64_t>(units * 1e6);
+    return fromNanoseconds(nanoseconds);
+  }
+
+  // @see https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp
+  constexpr double toDOMHighResTimeStamp() const {
+    return static_cast<std::chrono::duration<double, std::milli>>(
+               chronoDuration_)
+        .count();
+  }
+
+  constexpr HighResDuration operator+(const HighResDuration& rhs) const {
+    return HighResDuration(chronoDuration_ + rhs.chronoDuration_);
+  }
+
+  constexpr HighResDuration operator+(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return HighResDuration(chronoDuration_ + rhs);
+  }
+
+  constexpr HighResDuration operator-(const HighResDuration& rhs) const {
+    return HighResDuration(chronoDuration_ - rhs.chronoDuration_);
+  }
+
+  constexpr HighResDuration operator-(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return HighResDuration(chronoDuration_ - rhs);
+  }
+
+  constexpr HighResDuration& operator+=(const HighResDuration& rhs) {
+    chronoDuration_ += rhs.chronoDuration_;
+    return *this;
+  }
+
+  constexpr HighResDuration& operator+=(
+      const std::chrono::steady_clock::duration& rhs) {
+    chronoDuration_ += rhs;
+    return *this;
+  }
+
+  constexpr HighResDuration& operator-=(const HighResDuration& rhs) {
+    chronoDuration_ -= rhs.chronoDuration_;
+    return *this;
+  }
+
+  constexpr HighResDuration& operator-=(
+      const std::chrono::steady_clock::duration& rhs) {
+    chronoDuration_ -= rhs;
+    return *this;
+  }
+
+  constexpr bool operator==(const HighResDuration& rhs) const {
+    return chronoDuration_ == rhs.chronoDuration_;
+  }
+
+  constexpr bool operator==(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return chronoDuration_ == rhs;
+  }
+
+  constexpr bool operator!=(const HighResDuration& rhs) const {
+    return chronoDuration_ != rhs.chronoDuration_;
+  }
+
+  constexpr bool operator!=(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return chronoDuration_ != rhs;
+  }
+
+  constexpr bool operator<(const HighResDuration& rhs) const {
+    return chronoDuration_ < rhs.chronoDuration_;
+  }
+
+  constexpr bool operator<(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return chronoDuration_ < rhs;
+  }
+
+  constexpr bool operator<=(const HighResDuration& rhs) const {
+    return chronoDuration_ <= rhs.chronoDuration_;
+  }
+
+  constexpr bool operator<=(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return chronoDuration_ <= rhs;
+  }
+
+  constexpr bool operator>(const HighResDuration& rhs) const {
+    return chronoDuration_ > rhs.chronoDuration_;
+  }
+
+  constexpr bool operator>(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return chronoDuration_ > rhs;
+  }
+
+  constexpr bool operator>=(const HighResDuration& rhs) const {
+    return chronoDuration_ >= rhs.chronoDuration_;
+  }
+
+  constexpr bool operator>=(
+      const std::chrono::steady_clock::duration& rhs) const {
+    return chronoDuration_ >= rhs;
+  }
+
+  constexpr operator std::chrono::steady_clock::duration() const {
+    return chronoDuration_;
+  }
+
+ private:
+  explicit constexpr HighResDuration(
+      std::chrono::steady_clock::duration chronoDuration)
+      : chronoDuration_(chronoDuration) {}
+
+  std::chrono::steady_clock::duration chronoDuration_;
+};
+
+/*
+ * A class representing a specific point in time with high precision.
+ *
+ * @see __docs__/README.md for more information.
+ */
+class HighResTimeStamp {
+  friend constexpr HighResDuration operator-(
+      const HighResTimeStamp& lhs,
+      const HighResTimeStamp& rhs);
+  friend constexpr HighResTimeStamp operator+(
+      const HighResTimeStamp& lhs,
+      const HighResDuration& rhs);
+  friend constexpr HighResTimeStamp operator-(
+      const HighResTimeStamp& lhs,
+      const HighResDuration& rhs);
+
+ public:
+  HighResTimeStamp() noexcept
+      : chronoTimePoint_(std::chrono::steady_clock::now()) {}
+
+  static constexpr HighResTimeStamp now() noexcept {
+    return HighResTimeStamp(std::chrono::steady_clock::now());
+  }
+
+  static constexpr HighResTimeStamp min() noexcept {
+    return HighResTimeStamp(std::chrono::steady_clock::time_point::min());
+  }
+
+  static constexpr HighResTimeStamp max() noexcept {
+    return HighResTimeStamp(std::chrono::steady_clock::time_point::max());
+  }
+
+  // @see https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp
+  static constexpr HighResTimeStamp fromDOMHighResTimeStamp(double units) {
+    auto nanoseconds = static_cast<int64_t>(units * 1e6);
+    return HighResTimeStamp(std::chrono::steady_clock::time_point(
+        std::chrono::nanoseconds(nanoseconds)));
+  }
+
+  // @see https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp
+  constexpr double toDOMHighResTimeStamp() const {
+    return HighResDuration(chronoTimePoint_.time_since_epoch())
+        .toDOMHighResTimeStamp();
+  }
+
+  // This method is expected to be used only when converting time stamps from
+  // external systems.
+  static constexpr HighResTimeStamp fromChronoSteadyClockTimePoint(
+      std::chrono::steady_clock::time_point chronoTimePoint) {
+    return HighResTimeStamp(chronoTimePoint);
+  }
+
+  // This method is provided for convenience, if you need to convert
+  // HighResTimeStamp to some common epoch with time stamps from other sources.
+  constexpr std::chrono::steady_clock::time_point toChronoSteadyClockTimePoint()
+      const {
+    return chronoTimePoint_;
+  }
+
+  constexpr bool operator==(const HighResTimeStamp& rhs) const {
+    return chronoTimePoint_ == rhs.chronoTimePoint_;
+  }
+
+  constexpr bool operator!=(const HighResTimeStamp& rhs) const {
+    return chronoTimePoint_ != rhs.chronoTimePoint_;
+  }
+
+  constexpr bool operator<(const HighResTimeStamp& rhs) const {
+    return chronoTimePoint_ < rhs.chronoTimePoint_;
+  }
+
+  constexpr bool operator<=(const HighResTimeStamp& rhs) const {
+    return chronoTimePoint_ <= rhs.chronoTimePoint_;
+  }
+
+  constexpr bool operator>(const HighResTimeStamp& rhs) const {
+    return chronoTimePoint_ > rhs.chronoTimePoint_;
+  }
+
+  constexpr bool operator>=(const HighResTimeStamp& rhs) const {
+    return chronoTimePoint_ >= rhs.chronoTimePoint_;
+  }
+
+  constexpr HighResTimeStamp& operator+=(const HighResDuration& rhs) {
+    chronoTimePoint_ += rhs.chronoDuration_;
+    return *this;
+  }
+
+  constexpr HighResTimeStamp& operator-=(const HighResDuration& rhs) {
+    chronoTimePoint_ -= rhs.chronoDuration_;
+    return *this;
+  }
+
+ private:
+  explicit constexpr HighResTimeStamp(
+      std::chrono::steady_clock::time_point chronoTimePoint)
+      : chronoTimePoint_(chronoTimePoint) {}
+
+  std::chrono::steady_clock::time_point chronoTimePoint_;
+};
+
+inline constexpr HighResDuration operator-(
+    const HighResTimeStamp& lhs,
+    const HighResTimeStamp& rhs) {
+  return HighResDuration(lhs.chronoTimePoint_ - rhs.chronoTimePoint_);
+}
+
+inline constexpr HighResTimeStamp operator+(
+    const HighResTimeStamp& lhs,
+    const HighResDuration& rhs) {
+  return HighResTimeStamp(lhs.chronoTimePoint_ + rhs.chronoDuration_);
+}
+
+inline constexpr HighResTimeStamp operator-(
+    const HighResTimeStamp& lhs,
+    const HighResDuration& rhs) {
+  return HighResTimeStamp(lhs.chronoTimePoint_ - rhs.chronoDuration_);
+}
+
+} // namespace facebook::react

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.81.0</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.81.2</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>81</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>2</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>81863d6ae455c6d92f9ec8db6c9c4fe350a1c5b5</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>2589a216e30d0edb9b2be922ba8b5a3fb6ce2591</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/YGEnums.h

@@ -0,0 +1,146 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+// clang-format off
+#pragma once
+#include <yoga/YGMacros.h>
+
+YG_EXTERN_C_BEGIN
+
+YG_ENUM_DECL(
+    YGAlign,
+    YGAlignAuto,
+    YGAlignFlexStart,
+    YGAlignCenter,
+    YGAlignFlexEnd,
+    YGAlignStretch,
+    YGAlignBaseline,
+    YGAlignSpaceBetween,
+    YGAlignSpaceAround,
+    YGAlignSpaceEvenly)
+
+YG_ENUM_DECL(
+    YGBoxSizing,
+    YGBoxSizingBorderBox,
+    YGBoxSizingContentBox)
+
+YG_ENUM_DECL(
+    YGDimension,
+    YGDimensionWidth,
+    YGDimensionHeight)
+
+YG_ENUM_DECL(
+    YGDirection,
+    YGDirectionInherit,
+    YGDirectionLTR,
+    YGDirectionRTL)
+
+YG_ENUM_DECL(
+    YGDisplay,
+    YGDisplayFlex,
+    YGDisplayNone,
+    YGDisplayContents)
+
+YG_ENUM_DECL(
+    YGEdge,
+    YGEdgeLeft,
+    YGEdgeTop,
+    YGEdgeRight,
+    YGEdgeBottom,
+    YGEdgeStart,
+    YGEdgeEnd,
+    YGEdgeHorizontal,
+    YGEdgeVertical,
+    YGEdgeAll)
+
+YG_ENUM_DECL(
+    YGErrata,
+    YGErrataNone = 0,
+    YGErrataStretchFlexBasis = 1,
+    YGErrataAbsolutePositionWithoutInsetsExcludesPadding = 2,
+    YGErrataAbsolutePercentAgainstInnerSize = 4,
+    YGErrataAll = 2147483647,
+    YGErrataClassic = 2147483646)
+YG_DEFINE_ENUM_FLAG_OPERATORS(YGErrata)
+
+YG_ENUM_DECL(
+    YGExperimentalFeature,
+    YGExperimentalFeatureWebFlexBasis,
+    YGExperimentalFeatureCallMeasureCallbackOnAllNodes) // [Win] - Only used within NetUI in Office - Keep this flag at the end of the enum
+
+YG_ENUM_DECL(
+    YGFlexDirection,
+    YGFlexDirectionColumn,
+    YGFlexDirectionColumnReverse,
+    YGFlexDirectionRow,
+    YGFlexDirectionRowReverse)
+
+YG_ENUM_DECL(
+    YGGutter,
+    YGGutterColumn,
+    YGGutterRow,
+    YGGutterAll)
+
+YG_ENUM_DECL(
+    YGJustify,
+    YGJustifyFlexStart,
+    YGJustifyCenter,
+    YGJustifyFlexEnd,
+    YGJustifySpaceBetween,
+    YGJustifySpaceAround,
+    YGJustifySpaceEvenly)
+
+YG_ENUM_DECL(
+    YGLogLevel,
+    YGLogLevelError,
+    YGLogLevelWarn,
+    YGLogLevelInfo,
+    YGLogLevelDebug,
+    YGLogLevelVerbose,
+    YGLogLevelFatal)
+
+YG_ENUM_DECL(
+    YGMeasureMode,
+    YGMeasureModeUndefined,
+    YGMeasureModeExactly,
+    YGMeasureModeAtMost)
+
+YG_ENUM_DECL(
+    YGNodeType,
+    YGNodeTypeDefault,
+    YGNodeTypeText)
+
+YG_ENUM_DECL(
+    YGOverflow,
+    YGOverflowVisible,
+    YGOverflowHidden,
+    YGOverflowScroll)
+
+YG_ENUM_DECL(
+    YGPositionType,
+    YGPositionTypeStatic,
+    YGPositionTypeRelative,
+    YGPositionTypeAbsolute)
+
+YG_ENUM_DECL(
+    YGUnit,
+    YGUnitUndefined,
+    YGUnitPoint,
+    YGUnitPercent,
+    YGUnitAuto,
+    YGUnitMaxContent,
+    YGUnitFitContent,
+    YGUnitStretch)
+
+YG_ENUM_DECL(
+    YGWrap,
+    YGWrapNoWrap,
+    YGWrapWrap,
+    YGWrapWrapReverse)
+
+YG_EXTERN_C_END