react-native-windows 0.72.13 → 0.73.0-preview.1

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewEventEmitter.cpp

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "HostPlatformViewEventEmitter.h"
+
+namespace facebook::react {
+
+#pragma mark - Keyboard Events
+
+static jsi::Value keyEventPayload(jsi::Runtime &runtime, KeyEvent const &event) {
+  auto payload = jsi::Object(runtime);
+  payload.setProperty(runtime, "key", jsi::String::createFromUtf8(runtime, event.key));
+  payload.setProperty(runtime, "code", jsi::String::createFromUtf8(runtime, event.code));
+  payload.setProperty(runtime, "ctrlKey", event.ctrlKey);
+  payload.setProperty(runtime, "shiftKey", event.shiftKey);
+  payload.setProperty(runtime, "altKey", event.altKey);
+  payload.setProperty(runtime, "metaKey", event.metaKey);
+  return payload;
+};
+
+void HostPlatformViewEventEmitter::onKeyDown(KeyEvent const &keyEvent) const {
+  dispatchEvent("keyDown", [keyEvent](jsi::Runtime &runtime) { return keyEventPayload(runtime, keyEvent); });
+}
+
+void HostPlatformViewEventEmitter::onKeyUp(KeyEvent const &keyEvent) const {
+  dispatchEvent("keyUp", [keyEvent](jsi::Runtime &runtime) { return keyEventPayload(runtime, keyEvent); });
+}
+
+#pragma mark - Focus Events
+
+void HostPlatformViewEventEmitter::onFocus() const {
+  dispatchEvent("focus");
+}
+
+void HostPlatformViewEventEmitter::onBlur() const {
+  dispatchEvent("blur");
+}
+
+#pragma mark - Mouse Events
+
+void HostPlatformViewEventEmitter::onMouseEnter(PointerEvent const &pointerEvent) const {
+  dispatchEvent(
+      "mouseEnter",
+      std::make_shared<PointerEvent>(pointerEvent),
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+void HostPlatformViewEventEmitter::onMouseLeave(PointerEvent const &pointerEvent) const {
+  dispatchEvent(
+      "mouseLeave",
+      std::make_shared<PointerEvent>(pointerEvent),
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+} // namespace facebook::react
+
+// @generated SignedSource<<a6f36c63efa0edf80beb29b0187deb77>>

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewEventEmitter.h

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/components/view/BaseViewEventEmitter.h>
+#include "KeyEvent.h"
+
+namespace facebook::react {
+
+class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
+ public:
+  using BaseViewEventEmitter::BaseViewEventEmitter;
+
+#pragma mark - Keyboard Events
+
+  void onKeyDown(KeyEvent const &keyEvent) const;
+  void onKeyUp(KeyEvent const &keyEvent) const;
+
+#pragma mark - Focus Events
+
+  void onFocus() const;
+  void onBlur() const;
+
+#pragma mark - Mouse Events
+
+  void onMouseEnter(PointerEvent const &pointerEvent) const;
+  void onMouseLeave(PointerEvent const &pointerEvent) const;
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "HostPlatformViewProps.h"
+
+#include <react/renderer/components/view/conversions.h>
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/utils/CoreFeatures.h>
+
+namespace facebook::react {
+
+HostPlatformViewProps::HostPlatformViewProps(
+    const PropsParserContext &context,
+    const HostPlatformViewProps &sourceProps,
+    const RawProps &rawProps,
+    bool shouldSetRawProps)
+    : BaseViewProps(context, sourceProps, rawProps),
+      windowsEvents(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.windowsEvents
+                                                 : convertRawProp(context, rawProps, sourceProps.windowsEvents, {})),
+      enableFocusRing(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.enableFocusRing
+              : convertRawProp(context, rawProps, "enableFocusRing", sourceProps.enableFocusRing, true)),
+      focusable(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.focusable
+              : convertRawProp(context, rawProps, "focusable", sourceProps.focusable, {})) {}
+
+#define WINDOWS_VIEW_EVENT_CASE(eventType)                    \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): {       \
+    const auto offset = WindowsViewEvents::Offset::eventType; \
+    WindowsViewEvents defaultViewEvents{};                    \
+    bool res = defaultViewEvents[offset];                     \
+    if (value.hasValue()) {                                   \
+      fromRawValue(context, value, res);                      \
+    }                                                         \
+    windowsEvents[offset] = res;                              \
+    return;                                                   \
+  }
+
+void HostPlatformViewProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  // All Props structs setProp methods must always, unconditionally,
+  // call all super::setProp methods, since multiple structs may
+  // reuse the same values.
+  BaseViewProps::setProp(context, hash, propName, value);
+
+  static auto defaults = HostPlatformViewProps{};
+
+  switch (hash) {
+    WINDOWS_VIEW_EVENT_CASE(Focus);
+    WINDOWS_VIEW_EVENT_CASE(Blur);
+    WINDOWS_VIEW_EVENT_CASE(KeyUp);
+    WINDOWS_VIEW_EVENT_CASE(KeyDown);
+    WINDOWS_VIEW_EVENT_CASE(MouseEnter);
+    WINDOWS_VIEW_EVENT_CASE(MouseLeave);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(enableFocusRing);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(keyDownEvents);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(keyUpEvents);
+  }
+}
+
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.h

@@ -3,8 +3,31 @@
 
 #pragma once
 
-#include <react/components/view/windows/WindowsViewProps.h>
+#include <react/renderer/components/view/BaseViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include "KeyEvent.h"
+#include "WindowsViewEvents.h"
 
 namespace facebook::react {
-using HostPlatformViewProps = WindowsViewProps;
+class HostPlatformViewProps : public BaseViewProps {
+ public:
+  HostPlatformViewProps() = default;
+  HostPlatformViewProps(
+      const PropsParserContext &context,
+      const HostPlatformViewProps &sourceProps,
+      const RawProps &rawProps,
+      bool shouldSetRawProps = true);
+
+  void
+  setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, RawValue const &value);
+
+  WindowsViewEvents windowsEvents{};
+  bool enableFocusRing{true};
+  bool focusable{false};
+
+  // std::optional<std::string> overflowAnchor{};
+  // std::optional<std::string> tooltip{};
+  std::vector<HandledKeyEvent> keyDownEvents{};
+  std::vector<HandledKeyEvent> keyUpEvents{};
+};
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
+
+namespace facebook::react::HostPlatformViewTraitsInitializer {
+
+inline bool formsStackingContext(ViewProps const &viewProps) {
+  return viewProps.windowsEvents.bits.any();
+}
+
+inline bool formsView(ViewProps const &viewProps) {
+  return viewProps.focusable;
+}
+
+inline ShadowNodeTraits::Trait extraTraits() {
+  return ShadowNodeTraits::Trait::None;
+}
+
+} // namespace facebook::react::HostPlatformViewTraitsInitializer

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/KeyEvent.h

@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/graphics/Float.h>
+#include <string>
+
+namespace facebook::react {
+
+/*
+ * Describes an individual key event.
+ */
+struct BaseKeyEvent {
+  /**
+   * The code for the event aligned to https://www.w3.org/TR/uievents-code/.
+   */
+  std::string code{};
+
+  /*
+   * A flag indicating if the alt key is pressed.
+   */
+  bool altKey{false};
+
+  /*
+   * A flag indicating if the control key is pressed.
+   */
+  bool ctrlKey{false};
+
+  /*
+   * A flag indicating if the shift key is pressed.
+   */
+  bool shiftKey{false};
+
+  /*
+   * A flag indicating if the meta key is pressed.
+   */
+  bool metaKey{false};
+};
+
+inline static bool operator==(const BaseKeyEvent &lhs, const BaseKeyEvent &rhs) {
+  return lhs.code == rhs.code && lhs.altKey == rhs.altKey && lhs.ctrlKey == rhs.ctrlKey &&
+      lhs.shiftKey == rhs.shiftKey && lhs.metaKey == rhs.metaKey;
+}
+
+/**
+ * Event phase indicator matching the EventPhase in React.
+ * EventPhase includes None, Capturing, AtTarget, Bubbling.
+ */
+enum class HandledEventPhase { Capturing = 1, Bubbling = 3 };
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, HandledEventPhase &result) {
+  if (value.hasType<int>()) {
+    result = static_cast<HandledEventPhase>((int)value);
+    return;
+  }
+
+  LOG(ERROR) << "Unsupported HandledKeyEvent::EventPhase type";
+}
+
+/**
+ * Describes a handled key event declaration.
+ */
+struct HandledKeyEvent : BaseKeyEvent {
+  /**
+   * The phase at which the event should be marked as handled.
+   */
+  HandledEventPhase handledEventPhase{HandledEventPhase::Bubbling};
+};
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, HandledKeyEvent &result) {
+  if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
+    auto map = (std::unordered_map<std::string, RawValue>)value;
+
+    auto attrIterator = map.find("handledEventPhase");
+    if (attrIterator != map.end())
+      fromRawValue(context, attrIterator->second, result.handledEventPhase);
+    attrIterator = map.find("altKey");
+    if (attrIterator != map.end())
+      fromRawValue(context, attrIterator->second, result.altKey);
+    attrIterator = map.find("ctrlKey");
+    if (attrIterator != map.end())
+      fromRawValue(context, attrIterator->second, result.ctrlKey);
+    attrIterator = map.find("metaKey");
+    if (attrIterator != map.end())
+      fromRawValue(context, attrIterator->second, result.metaKey);
+    attrIterator = map.find("shiftKey");
+    if (attrIterator != map.end())
+      fromRawValue(context, attrIterator->second, result.shiftKey);
+    attrIterator = map.find("code");
+    if (attrIterator != map.end())
+      fromRawValue(context, attrIterator->second, result.code);
+    return;
+  }
+
+  LOG(ERROR) << "Unsupported HandledKeyEvent type";
+}
+
+inline static bool operator==(const HandledKeyEvent &lhs, const HandledKeyEvent &rhs) {
+  return lhs.handledEventPhase == rhs.handledEventPhase &&
+      static_cast<BaseKeyEvent>(lhs) == static_cast<BaseKeyEvent>(rhs);
+}
+
+struct KeyEvent : BaseKeyEvent {
+  /**
+   * The key for the event aligned to https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values.
+   */
+  std::string key{};
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/WindowsViewEvents.h

@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+#include <array>
+#include <bitset>
+#include <cmath>
+#include <optional>
+
+namespace facebook {
+namespace react {
+
+struct WindowsViewEvents {
+  std::bitset<32> bits{};
+
+  enum class Offset : std::size_t {
+    Focus = 0,
+    Blur = 1,
+    KeyUp = 2,
+    KeyDown = 3,
+    MouseEnter = 4,
+    MouseLeave = 5,
+  };
+
+  constexpr bool operator[](const Offset offset) const {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+
+  std::bitset<32>::reference operator[](const Offset offset) {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+};
+
+inline static bool operator==(WindowsViewEvents const &lhs, WindowsViewEvents const &rhs) {
+  return lhs.bits == rhs.bits;
+}
+
+inline static bool operator!=(WindowsViewEvents const &lhs, WindowsViewEvents const &rhs) {
+  return lhs.bits != rhs.bits;
+}
+
+static inline WindowsViewEvents convertRawProp(
+    const PropsParserContext &context,
+    const RawProps &rawProps,
+    const WindowsViewEvents &sourceValue,
+    const WindowsViewEvents &defaultValue) {
+  WindowsViewEvents result{};
+  using Offset = WindowsViewEvents::Offset;
+
+  // Focus Events
+  result[Offset::Focus] =
+      convertRawProp(context, rawProps, "onFocus", sourceValue[Offset::Focus], defaultValue[Offset::Focus]);
+  result[Offset::Blur] =
+      convertRawProp(context, rawProps, "onBlur", sourceValue[Offset::Blur], defaultValue[Offset::Blur]);
+
+  // Key Events
+  result[Offset::KeyDown] =
+      convertRawProp(context, rawProps, "onKeyDown", sourceValue[Offset::KeyDown], defaultValue[Offset::KeyDown]);
+  result[Offset::KeyUp] =
+      convertRawProp(context, rawProps, "onKeyUp", sourceValue[Offset::KeyUp], defaultValue[Offset::KeyUp]);
+
+  // Mouse Events
+  result[Offset::MouseEnter] = convertRawProp(
+      context, rawProps, "onMouseEnter", sourceValue[Offset::MouseEnter], defaultValue[Offset::MouseEnter]);
+  result[Offset::MouseLeave] = convertRawProp(
+      context, rawProps, "onMouseLeave", sourceValue[Offset::MouseLeave], defaultValue[Offset::MouseLeave]);
+
+  return result;
+}
+
+} // namespace react
+} // namespace facebook

package/Microsoft.ReactNative/Fabric/platform/react/renderer/core/graphicsConversions.h

@@ -7,7 +7,8 @@
 
 #pragma once
 
-#include <butter/map.h>
+#include <unordered_map>
+
 #include <glog/logging.h>
 #include <react/debug/react_native_expect.h>
 #include <react/renderer/core/PropsParserContext.h>
@@ -23,8 +24,7 @@
 // #include <react/renderer/graphis/PlatformColorParser.h>
 // WIndows]
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 #pragma mark - Color
 
@@ -47,18 +47,16 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
     colorComponents.blue = items.at(2);
     colorComponents.alpha = length == 4 ? items.at(3) : 1.0f;
     // [Windows - Embed WindowBrush into SharedColor instead of trying to parse PlatformColor into RGB
-  } else if (value.hasType<butter::map<std::string, std::string>>()) {
-    auto map = (butter::map<std::string, std::string>)value;
-    for (const auto &pair : map) {
-      if (pair.first == "windowsbrush") {
-        result = SharedColor(std::string(pair.second));
-        return;
-      }
+  } else if (value.hasType<std::unordered_map<std::string, std::vector<std::string>>>()) {
+    auto map = (std::unordered_map<std::string, std::vector<std::string>>)value;
+    if (map.find("windowsbrush") != map.end()) {
+      result = SharedColor(std::move(map["windowsbrush"]));
+      return;
     }
   }
   // Windows]
-
   result = colorFromComponents(colorComponents);
+  return;
 }
 
 #ifdef ANDROID
@@ -79,8 +77,8 @@ inline std::string toString(const SharedColor &value) {
 #pragma mark - Geometry
 
 inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Point &result) {
-  if (value.hasType<butter::map<std::string, Float>>()) {
-    auto map = (butter::map<std::string, Float>)value;
+  if (value.hasType<std::unordered_map<std::string, Float>>()) {
+    auto map = (std::unordered_map<std::string, Float>)value;
     for (const auto &pair : map) {
       if (pair.first == "x") {
         result.x = pair.second;
@@ -107,8 +105,8 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
 }
 
 inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Size &result) {
-  if (value.hasType<butter::map<std::string, Float>>()) {
-    auto map = (butter::map<std::string, Float>)value;
+  if (value.hasType<std::unordered_map<std::string, Float>>()) {
+    auto map = (std::unordered_map<std::string, Float>)value;
     for (const auto &pair : map) {
       if (pair.first == "width") {
         result.width = pair.second;
@@ -144,8 +142,8 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
     return;
   }
 
-  if (value.hasType<butter::map<std::string, Float>>()) {
-    auto map = (butter::map<std::string, Float>)value;
+  if (value.hasType<std::unordered_map<std::string, Float>>()) {
+    auto map = (std::unordered_map<std::string, Float>)value;
     for (const auto &pair : map) {
       if (pair.first == "top") {
         result.top = pair.second;
@@ -185,8 +183,8 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
     return;
   }
 
-  if (value.hasType<butter::map<std::string, Float>>()) {
-    auto map = (butter::map<std::string, Float>)value;
+  if (value.hasType<std::unordered_map<std::string, Float>>()) {
+    auto map = (std::unordered_map<std::string, Float>)value;
     for (const auto &pair : map) {
       if (pair.first == "topLeft") {
         result.topLeft = pair.second;
@@ -244,5 +242,4 @@ inline std::string toString(const CornerInsets &cornerInsets) {
       "}";
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react