react-native-windows 0.81.11 → 0.81.13

package/Libraries/Components/View/ViewPropTypes.windows.js

@@ -85,6 +85,8 @@ type MouseEventProps = $ReadOnly<{
 
 // Experimental/Work in Progress Pointer Event Callbacks (not yet ready for use)
 type PointerEventProps = $ReadOnly<{
+  onAuxClick?: ?(event: PointerEvent) => void, // [Windows]
+  onAuxClickCapture?: ?(event: PointerEvent) => void, // [Windows]
   onClick?: ?(event: PointerEvent) => void,
   onClickCapture?: ?(event: PointerEvent) => void,
   onPointerEnter?: ?(event: PointerEvent) => void,

package/Libraries/NativeComponent/BaseViewConfig.windows.js

@@ -85,6 +85,14 @@ const bubblingEventTypes = {
     },
   },
   // Experimental/Work in Progress Pointer Events (not yet ready for use)
+  // [Windows
+  topAuxClick: {
+    phasedRegistrationNames: {
+      captured: 'onAuxClickCapture',
+      bubbled: 'onAuxClick',
+    },
+  },
+  // Windows]
   topClick: {
     phasedRegistrationNames: {
       captured: 'onClickCapture',
@@ -383,7 +391,6 @@ const validAttributesForNonEventProps = {
   keyUpEvents: true, // [Windows]
   tabIndex: true, // [Windows]
   tooltip: true, // [Windows]
-  onClick: true, // [Windows]
   enableFocusRing: true, // [Windows]
   importantForAccessibility: true, // [Windows]
 
@@ -424,6 +431,8 @@ const validAttributesForEventProps = {
   onTouchCancel: true,
 
   // Pointer events
+  onAuxClick: true, // [Windows]
+  onAuxClickCapture: true, // [Windows]
   onClick: true,
   onClickCapture: true,
   onPointerUp: true,

package/Microsoft.ReactNative/Fabric/Composition/CompositionEventHandler.cpp

@@ -992,8 +992,6 @@ void CompositionEventHandler::UpdateActiveTouch(
   // activeTouch.touch.shiftKey = false;
   // activeTouch.touch.ctrlKey = false;
   // activeTouch.touch.altKey = false;
-
-  // activeTouch.touch.isPrimary = true;
 }
 
 facebook::react::PointerEvent CreatePointerEventFromIncompleteHoverData(
@@ -1252,7 +1250,7 @@ void CompositionEventHandler::onPointerPressed(
                   ->eventEmitterAtPoint(ptLocal)) {
         activeTouch.eventEmitter = eventEmitter;
         activeTouch.touch.target = targetComponentView.Tag();
-        // activeTouch.componentView = componentView;
+        activeTouch.initialComponentView = targetComponentView;
         break;
       }
       targetComponentView = targetComponentView.Parent();
@@ -1260,7 +1258,7 @@ void CompositionEventHandler::onPointerPressed(
 
     UpdateActiveTouch(activeTouch, ptScaled, ptLocal);
 
-    // activeTouch.touch.isPrimary = true;
+    activeTouch.isPrimary = pointerId == 1;
     activeTouch.touch.identifier = pointerId;
 
     // If the pointer has not been marked as hovering over views before the touch started, we register
@@ -1465,11 +1463,26 @@ facebook::react::PointerEvent CompositionEventHandler::CreatePointerEventFromAct
 
   // event.tangentialPressure = 0.0;
   // event.twist = 0;
-  // event.isPrimary = activeTouch.isPrimary;
+  event.isPrimary = activeTouch.isPrimary;
 
   return event;
 }
 
+bool CompositionEventHandler::IsPointerWithinInitialTree(const ActiveTouch &activeTouch) noexcept {
+  auto initialComponentView = activeTouch.initialComponentView.view();
+  if (!initialComponentView)
+    return false;
+
+  auto initialViewSet = GetTouchableViewsInPathToRoot(initialComponentView);
+
+  for (const auto &view : initialViewSet) {
+    if (view.Tag() == activeTouch.touch.target)
+      return true;
+  }
+
+  return false;
+}
+
 // If we have events that include multiple pointer updates, we should change arg from pointerId to vector<pointerId>
 void CompositionEventHandler::DispatchTouchEvent(
     TouchEventType eventType,
@@ -1526,6 +1539,13 @@ void CompositionEventHandler::DispatchTouchEvent(
         }
         case TouchEventType::End:
           activeTouch.eventEmitter->onPointerUp(pointerEvent);
+          if (pointerEvent.isPrimary && pointerEvent.button == 0) {
+            if (IsPointerWithinInitialTree(activeTouch)) {
+              activeTouch.eventEmitter->onClick(pointerEvent);
+            }
+          } else if (IsPointerWithinInitialTree(activeTouch)) {
+            activeTouch.eventEmitter->onAuxClick(pointerEvent);
+          }
           break;
         case TouchEventType::Cancel:
         case TouchEventType::CaptureLost:

package/Microsoft.ReactNative/Fabric/Composition/CompositionEventHandler.h

@@ -138,9 +138,10 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
     /*
      * A component view on which the touch was begun.
      */
-    //__strong UIView<RCTComponentViewProtocol> *componentView = nil;
+    ReactTaggedView initialComponentView{nullptr};
   };
 
+  static bool IsPointerWithinInitialTree(const ActiveTouch &activeTouch) noexcept;
   static bool IsEndishEventType(TouchEventType eventType) noexcept;
   static const char *PointerTypeCStringFromUITouchType(UITouchType type) noexcept;
   static facebook::react::PointerEvent CreatePointerEventFromActiveTouch(

package/Microsoft.ReactNative/Fabric/ReactTaggedView.h

@@ -18,7 +18,7 @@ struct ReactTaggedView {
   ReactTaggedView(const winrt::Microsoft::ReactNative::ComponentView &componentView)
       : m_view(componentView), m_tag(componentView ? componentView.Tag() : -1) {}
 
-  winrt::Microsoft::ReactNative::ComponentView view() noexcept {
+  winrt::Microsoft::ReactNative::ComponentView view() const noexcept {
     if (!m_view) {
       return nullptr;
     }
@@ -37,7 +37,7 @@ struct ReactTaggedView {
 
  private:
   facebook::react::Tag m_tag;
-  winrt::weak_ref<winrt::Microsoft::ReactNative::ComponentView> m_view;
+  mutable winrt::weak_ref<winrt::Microsoft::ReactNative::ComponentView> m_view;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative.Cxx/ModuleRegistration.h

@@ -17,19 +17,23 @@
 // The macros below are internal implementation details for macro defined in nativeModules.h
 //
 
+// ADL-based fallback: returns false for any type not tagged by the macros below.
+// Using ADL instead of explicit template specialization allows the macros to be
+// used inside a namespace (explicit specializations of a global template must
+// occur at global scope, which the macros cannot guarantee).
 template <typename T>
-struct IsReactTurboModule;
+constexpr bool ReactIsReactTurboModuleImpl(T *) noexcept {
+  return false;
+}
 
-// Default to false if no specific override
 template <typename T>
-struct IsReactTurboModule : std::false_type {};
+struct IsReactTurboModule : std::bool_constant<ReactIsReactTurboModuleImpl(static_cast<T *>(nullptr))> {};
 
 #define INTERNAL_REACT_MODULE_REGISTRATION_AND_PROVIDER(                                                            \
     moduleStruct, moduleName, eventEmitterName, isReactTurboModule)                                                 \
   struct moduleStruct;                                                                                              \
                                                                                                                     \
-  template <>                                                                                                       \
-  struct IsReactTurboModule<moduleStruct> : std::isReactTurboModule##_type {};                                      \
+  constexpr bool ReactIsReactTurboModuleImpl(moduleStruct *) noexcept { return isReactTurboModule; }                \
                                                                                                                     \
   template <class TDummy>                                                                                           \
   struct moduleStruct##_ModuleRegistration final : winrt::Microsoft::ReactNative::ModuleRegistration {              \
@@ -66,17 +70,16 @@ struct IsReactTurboModule : std::false_type {};
   INTERNAL_REACT_RECOMPOSER_4(     \
       (__VA_ARGS__, INTERNAL_REACT_MODULE_3_ARGS, INTERNAL_REACT_MODULE_2_ARGS, INTERNAL_REACT_MODULE_1_ARG, ))
 
-#define INTERNAL_REACT_MODULE_NO_REGISTRATION_AND_PROVIDER(                                            \
-    moduleStruct, moduleName, eventEmitterName, isReactTurboModule)                                    \
-  struct moduleStruct;                                                                                 \
-                                                                                                       \
-  template <>                                                                                          \
-  struct IsReactTurboModule<moduleStruct> : std::isReactTurboModule##_type {};                         \
-                                                                                                       \
-  template <class TRegistry>                                                                           \
-  constexpr void GetReactModuleInfo(moduleStruct *, TRegistry &registry) noexcept {                    \
-    registry.RegisterModule(                                                                           \
-        moduleName, eventEmitterName, winrt::Microsoft::ReactNative::ReactAttributeId<__COUNTER__>{}); \
+#define INTERNAL_REACT_MODULE_NO_REGISTRATION_AND_PROVIDER(                                                           \
+    moduleStruct, moduleName, eventEmitterName, isReactTurboModule)                                                   \
+  struct moduleStruct;                                                                                                \
+                                                                                                                      \
+  [[maybe_unused]] constexpr bool ReactIsReactTurboModuleImpl(moduleStruct *) noexcept { return isReactTurboModule; } \
+                                                                                                                      \
+  template <class TRegistry>                                                                                          \
+  constexpr void GetReactModuleInfo(moduleStruct *, TRegistry &registry) noexcept {                                   \
+    registry.RegisterModule(                                                                                          \
+        moduleName, eventEmitterName, winrt::Microsoft::ReactNative::ReactAttributeId<__COUNTER__>{});                \
   }
 
 // Another version of REACT_MODULE but does not do auto registration

package/Microsoft.ReactNative.Cxx/NativeModules.h

@@ -918,7 +918,7 @@ struct ModuleEventFieldInfo<TFunc<void(TArgs...)> TModule::*> {
       return [module = static_cast<ModuleType *>(module), field](IReactContext const &) noexcept {
         // Default emitter will do nothing
         // This will be replaced with a method that will call the jsi EventEmitter when JS requests the emitter
-        module->*field = [](TArgs... args) noexcept {};
+        module->*field = [](TArgs... /*args*/) noexcept {};
       };
     } else {
       return [module = static_cast<ModuleType *>(module), field, eventName, eventEmitterName](

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.81.11</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.81.13</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>81</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>11</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>13</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>a964ab588ab12db0b975f848c88d7a0b750d6cba</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>57c33949c2f2863a51817500cec9bdd795d459dc</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

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/package.json

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