react-native-windows 0.84.0 → 0.85.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/text/ParagraphShadowNode.cpp

@@ -145,7 +145,7 @@ void ParagraphShadowNode::setTextLayoutManager(
 template <typename ParagraphStateT>
 void ParagraphShadowNode::updateStateIfNeeded(
     const Content& content,
-    const MeasuredPreparedLayout& layout) {
+    const MeasuredPreparedTextLayout& layout) {
   ensureUnsealed();
 
   auto& state = static_cast<const ParagraphStateT&>(getStateData());
@@ -183,10 +183,10 @@ void ParagraphShadowNode::updateStateIfNeeded(const Content& content) {
           textLayoutManager_});
 }
 
-MeasuredPreparedLayout* ParagraphShadowNode::findUsableLayout() {
-  MeasuredPreparedLayout* ret = nullptr;
+MeasuredPreparedTextLayout* ParagraphShadowNode::findUsableLayout() {
+  MeasuredPreparedTextLayout* ret = nullptr;
 
-  if constexpr (TextLayoutManagerExtended::supportsPreparedLayout()) {
+  if constexpr (TextLayoutManagerExtended::supportsPreparedTextLayout()) {
     // We consider the layout to be reusable, if our content measurement,
     // combined with padding/border (not snapped) exactly corresponds to the
     // measurement of the node, before layout rounding. We may not find a
@@ -223,7 +223,7 @@ Size ParagraphShadowNode::rawContentSize() {
 Size ParagraphShadowNode::measureContent(
     const LayoutContext& layoutContext,
     const LayoutConstraints& layoutConstraints) const {
-  if constexpr (TextLayoutManagerExtended::supportsPreparedLayout()) {
+  if constexpr (TextLayoutManagerExtended::supportsPreparedTextLayout()) {
     for (const auto& layout : measuredLayouts_) {
       if (layout.layoutConstraints == layoutConstraints) {
         return layout.measurement.size;
@@ -239,7 +239,7 @@ Size ParagraphShadowNode::measureContent(
       .surfaceId = getSurfaceId(),
   };
 
-  if constexpr (TextLayoutManagerExtended::supportsPreparedLayout()) {
+  if constexpr (TextLayoutManagerExtended::supportsPreparedTextLayout()) {
     if (ReactNativeFeatureFlags::enablePreparedTextLayout()) {
       TextLayoutManagerExtended tme(*textLayoutManager_);
 
@@ -252,12 +252,12 @@ Size ParagraphShadowNode::measureContent(
           preparedLayout, textLayoutContext, layoutConstraints);
 
       measuredLayouts_.push_back(
-          MeasuredPreparedLayout{
+          MeasuredPreparedTextLayout{
               .layoutConstraints = layoutConstraints,
               .measurement = measurement,
-              // PreparedLayout is not trivially copyable on all platforms
+              // PreparedTextLayout is not trivially copyable on all platforms
               // NOLINTNEXTLINE(performance-move-const-arg)
-              .preparedLayout = std::move(preparedLayout)});
+              .preparedTextLayout = std::move(preparedLayout)});
       assert_valid_size(measurement.size, layoutConstraints);
       return measurement.size;
     }
@@ -317,7 +317,7 @@ void ParagraphShadowNode::layout(LayoutContext layoutContext) {
   auto measuredLayout = findUsableLayout();
 
   if constexpr (
-      TextLayoutManagerExtended::supportsPreparedLayout() &&
+      TextLayoutManagerExtended::supportsPreparedTextLayout() &&
       std::is_constructible_v<
           ParagraphState,
           decltype(content.attributedString),

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/AccessibilityPrimitives.h

@@ -56,17 +56,13 @@ inline static bool operator==(const AccessibilityAction &lhs, const Accessibilit
   return lhs.name == rhs.name && lhs.label == rhs.label;
 }
 
-inline static bool operator!=(const AccessibilityAction &lhs, const AccessibilityAction &rhs)
-{
-  return !(rhs == lhs);
-}
-
 struct AccessibilityState {
   bool disabled{false};
   std::optional<bool> selected{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionItemProvider Implementation
   bool busy{false};
   std::optional<bool> expanded{std::nullopt};
-  enum CheckedState { Unchecked, Checked, Mixed, None } checked{None};
+  enum CheckedState { Unchecked, Checked, Mixed, None };
+  CheckedState checked{CheckedState::None};
   std::optional<bool> readOnly{std::nullopt}; // [Windows] - Do not remove; required for Windows IRangeValueProvider and IValueProvider Implementation
   std::optional<bool> multiselectable{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionProvider Implementation
   std::optional<bool> required{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionProvider Implementation
@@ -78,11 +74,6 @@ constexpr bool operator==(const AccessibilityState &lhs, const AccessibilityStat
       lhs.busy == rhs.busy && lhs.expanded == rhs.expanded;
 }
 
-constexpr bool operator!=(const AccessibilityState &lhs, const AccessibilityState &rhs)
-{
-  return !(rhs == lhs);
-}
-
 struct AccessibilityLabelledBy {
   std::vector<std::string> value{};
 };
@@ -92,11 +83,6 @@ inline static bool operator==(const AccessibilityLabelledBy &lhs, const Accessib
   return lhs.value == rhs.value;
 }
 
-inline static bool operator!=(const AccessibilityLabelledBy &lhs, const AccessibilityLabelledBy &rhs)
-{
-  return !(lhs == rhs);
-}
-
 struct AccessibilityValue {
   std::optional<int> min;
   std::optional<int> max;
@@ -109,11 +95,6 @@ constexpr bool operator==(const AccessibilityValue &lhs, const AccessibilityValu
   return lhs.min == rhs.min && lhs.max == rhs.max && lhs.now == rhs.now && lhs.text == rhs.text;
 }
 
-constexpr bool operator!=(const AccessibilityValue &lhs, const AccessibilityValue &rhs)
-{
-  return !(rhs == lhs);
-}
-
 enum class ImportantForAccessibility : uint8_t {
   Auto,
   Yes,

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/TouchEventEmitter.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "TouchEventEmitter.h"
+
+namespace facebook::react {
+
+#pragma mark - Touches
+
+static jsi::Value touchesPayload(
+    jsi::Runtime& runtime,
+    const Touches& touches) {
+  auto array = jsi::Array(runtime, touches.size());
+  int i = 0;
+  for (const auto& touch : touches) {
+    auto object = jsi::Object(runtime);
+    setTouchPayloadOnObject(object, runtime, touch);
+    array.setValueAtIndex(runtime, i++, object);
+  }
+  return array;
+}
+
+static jsi::Value touchEventPayload(
+    jsi::Runtime& runtime,
+    const TouchEvent& event) {
+  auto object = jsi::Object(runtime);
+  object.setProperty(
+      runtime, "touches", touchesPayload(runtime, event.touches));
+  object.setProperty(
+      runtime, "changedTouches", touchesPayload(runtime, event.changedTouches));
+  object.setProperty(
+      runtime, "targetTouches", touchesPayload(runtime, event.targetTouches));
+
+  if (!event.changedTouches.empty()) {
+    const auto& firstChangedTouch = *event.changedTouches.begin();
+    setTouchPayloadOnObject(object, runtime, firstChangedTouch);
+  }
+  return object;
+}
+
+void TouchEventEmitter::dispatchTouchEvent(
+    std::string type,
+    TouchEvent event,
+    RawEvent::Category category) const {
+  dispatchEvent(
+      std::move(type),
+      [event = std::move(event)](jsi::Runtime& runtime) {
+        return touchEventPayload(runtime, event);
+      },
+      category);
+}
+
+void TouchEventEmitter::dispatchPointerEvent(
+    std::string type,
+    PointerEvent event,
+    RawEvent::Category category) const {
+  dispatchEvent(
+      std::move(type),
+      std::make_shared<PointerEvent>(std::move(event)),
+      category);
+}
+
+void TouchEventEmitter::onTouchStart(TouchEvent event) const {
+  dispatchTouchEvent(
+      "touchStart", std::move(event), RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onTouchMove(TouchEvent event) const {
+  dispatchUniqueEvent(
+      "touchMove", [event = std::move(event)](jsi::Runtime& runtime) {
+        return touchEventPayload(runtime, event);
+      });
+}
+
+void TouchEventEmitter::onTouchEnd(TouchEvent event) const {
+  dispatchTouchEvent(
+      "touchEnd", std::move(event), RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onTouchCancel(TouchEvent event) const {
+  dispatchTouchEvent(
+      "touchCancel", std::move(event), RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onAuxClick(PointerEvent event) const {
+  dispatchPointerEvent("auxClick", std::move(event), RawEvent::Category::Discrete);
+}
+
+void TouchEventEmitter::onClick(PointerEvent event) const {
+  dispatchPointerEvent("click", std::move(event), RawEvent::Category::Discrete);
+}
+
+void TouchEventEmitter::onPointerCancel(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerCancel", std::move(event), RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onPointerDown(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerDown", std::move(event), RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onPointerMove(PointerEvent event) const {
+  dispatchUniqueEvent(
+      "pointerMove", std::make_shared<PointerEvent>(std::move(event)));
+}
+
+void TouchEventEmitter::onPointerUp(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerUp", std::move(event), RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onPointerEnter(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerEnter", std::move(event), RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onPointerLeave(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerLeave", std::move(event), RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onPointerOver(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerOver", std::move(event), RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onPointerOut(PointerEvent event) const {
+  dispatchPointerEvent(
+      "pointerOut", std::move(event), RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onGotPointerCapture(PointerEvent event) const {
+  dispatchPointerEvent(
+      "gotPointerCapture",
+      std::move(event),
+      RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onLostPointerCapture(PointerEvent event) const {
+  dispatchPointerEvent(
+      "lostPointerCapture",
+      std::move(event),
+      RawEvent::Category::ContinuousEnd);
+}
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/TouchEventEmitter.h

@@ -0,0 +1,50 @@
+/*
+ * 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/renderer/components/view/PointerEvent.h>
+#include <react/renderer/components/view/TouchEvent.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/debug/DebugStringConvertible.h>
+
+namespace facebook::react {
+
+class TouchEventEmitter;
+
+using SharedTouchEventEmitter = std::shared_ptr<const TouchEventEmitter>;
+
+class TouchEventEmitter : public EventEmitter {
+ public:
+  using EventEmitter::EventEmitter;
+
+  void onTouchStart(TouchEvent event) const;
+  void onTouchMove(TouchEvent event) const;
+  void onTouchEnd(TouchEvent event) const;
+  void onTouchCancel(TouchEvent event) const;
+
+  void onAuxClick(PointerEvent event) const; // [Windows]
+  void onClick(PointerEvent event) const;
+  void onPointerCancel(PointerEvent event) const;
+  void onPointerDown(PointerEvent event) const;
+  void onPointerMove(PointerEvent event) const;
+  void onPointerUp(PointerEvent event) const;
+  void onPointerEnter(PointerEvent event) const;
+  void onPointerLeave(PointerEvent event) const;
+  void onPointerOver(PointerEvent event) const;
+  void onPointerOut(PointerEvent event) const;
+  void onGotPointerCapture(PointerEvent event) const;
+  void onLostPointerCapture(PointerEvent event) const;
+
+ private:
+  void dispatchTouchEvent(std::string type, TouchEvent event, RawEvent::Category category) const;
+  void dispatchPointerEvent(std::string type, PointerEvent event, RawEvent::Category category) const;
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "MapBuffer.h"
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+
+namespace facebook::react {
+
+static inline int32_t bucketOffset(int32_t index) {
+  return sizeof(MapBuffer::Header) + sizeof(MapBuffer::Bucket) * index;
+}
+
+static inline int32_t valueOffset(int32_t bucketIndex) {
+  return bucketOffset(bucketIndex) + offsetof(MapBuffer::Bucket, data);
+}
+
+// TODO T83483191: Extend MapBuffer C++ implementation to support basic random
+// access
+MapBuffer::MapBuffer(std::vector<uint8_t> data) : bytes_(std::move(data)) {
+  auto header = reinterpret_cast<const Header*>(bytes_.data());
+  count_ = header->count;
+
+  if (static_cast<size_t>(header->bufferSize) != bytes_.size()) { // [Windows #16261]
+    LOG(ERROR) << "Error: Data size does not match, expected "
+               << header->bufferSize << " found: " << bytes_.size();
+    abort();
+  }
+}
+
+int32_t MapBuffer::getKeyBucket(Key key) const {
+  int32_t lo = 0;
+  int32_t hi = count_ - 1;
+  while (lo <= hi) {
+    int32_t mid = (lo + hi) >> 1;
+
+    Key midVal =
+        *reinterpret_cast<const Key*>(bytes_.data() + bucketOffset(mid));
+
+    if (midVal < key) {
+      lo = mid + 1;
+    } else if (midVal > key) {
+      hi = mid - 1;
+    } else {
+      return mid;
+    }
+  }
+
+  return -1;
+}
+
+inline int32_t MapBuffer::getIntAtBucket(int32_t bucketIndex) const {
+  return *reinterpret_cast<const int32_t*>(
+      bytes_.data() + valueOffset(bucketIndex));
+}
+
+int32_t MapBuffer::getInt(Key key) const {
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return 0;
+  }
+
+  return getIntAtBucket(bucketIndex);
+}
+
+int64_t MapBuffer::getLong(Key key) const {
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return 0;
+  }
+
+  return *reinterpret_cast<const int64_t*>(
+      bytes_.data() + valueOffset(bucketIndex));
+}
+
+bool MapBuffer::getBool(Key key) const {
+  return getInt(key) != 0;
+}
+
+double MapBuffer::getDouble(Key key) const {
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return 0;
+  }
+
+  return *reinterpret_cast<const double*>(
+      bytes_.data() + valueOffset(bucketIndex));
+}
+
+int32_t MapBuffer::getDynamicDataOffset() const {
+  // The start of dynamic data can be calculated as the offset of the next
+  // key in the map
+  return bucketOffset(count_);
+}
+
+std::string MapBuffer::getString(Key key) const {
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return "";
+  }
+
+  int32_t offset = getDynamicDataOffset() + getIntAtBucket(bucketIndex);
+  int32_t stringLength =
+      *reinterpret_cast<const int32_t*>(bytes_.data() + offset);
+  const uint8_t* stringPtr = bytes_.data() + offset + sizeof(int);
+
+  return {stringPtr, stringPtr + stringLength};
+}
+
+MapBuffer MapBuffer::getMapBuffer(Key key) const {
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return MapBufferBuilder::EMPTY();
+  }
+
+  int32_t offset = getDynamicDataOffset() + getIntAtBucket(bucketIndex);
+  int32_t mapBufferLength =
+      *reinterpret_cast<const int32_t*>(bytes_.data() + offset);
+  int32_t maxLength = static_cast<int32_t>(bytes_.size() - offset - sizeof(int32_t)); // [Windows #16261]
+  if (mapBufferLength > maxLength) {
+    mapBufferLength = maxLength;
+  }
+
+  std::vector<uint8_t> value(mapBufferLength);
+
+  memcpy(
+      value.data(), bytes_.data() + offset + sizeof(int32_t), mapBufferLength);
+
+  return MapBuffer(std::move(value));
+}
+
+std::vector<MapBuffer> MapBuffer::getMapBufferList(MapBuffer::Key key) const {
+  auto bucketIndex = getKeyBucket(key);
+  react_native_assert(bucketIndex != -1 && "Key not found in MapBuffer");
+  if (bucketIndex == -1) {
+    return {};
+  }
+
+  std::vector<MapBuffer> mapBufferList;
+  int32_t offset = getDynamicDataOffset() + getIntAtBucket(bucketIndex);
+  int32_t mapBufferListLength =
+      *reinterpret_cast<const int32_t*>(bytes_.data() + offset);
+  offset = offset + sizeof(uint32_t);
+
+  int32_t curLen = 0;
+  while (curLen < mapBufferListLength) {
+    int32_t mapBufferLength =
+        *reinterpret_cast<const int32_t*>(bytes_.data() + offset + curLen);
+    curLen = curLen + sizeof(uint32_t);
+    std::vector<uint8_t> value(mapBufferLength);
+    memcpy(value.data(), bytes_.data() + offset + curLen, mapBufferLength);
+    mapBufferList.emplace_back(std::move(value));
+    curLen = curLen + mapBufferLength;
+  }
+  return mapBufferList;
+}
+
+size_t MapBuffer::size() const {
+  return bytes_.size();
+}
+
+const uint8_t* MapBuffer::data() const {
+  return bytes_.data();
+}
+
+uint16_t MapBuffer::count() const {
+  return count_;
+}
+
+} // namespace facebook::react