react-native 0.69.3 → 0.70.0-rc.2

package/ReactCommon/react/renderer/components/view/AccessibilityProps.cpp

@@ -15,126 +15,219 @@
 namespace facebook {
 namespace react {
 
+bool AccessibilityProps::enablePropIteratorSetter = false;
+
 AccessibilityProps::AccessibilityProps(
     const PropsParserContext &context,
     AccessibilityProps const &sourceProps,
     RawProps const &rawProps)
-    : accessible(convertRawProp(
-          context,
-          rawProps,
-          "accessible",
-          sourceProps.accessible,
-          false)),
-      accessibilityTraits(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityRole",
-          sourceProps.accessibilityTraits,
-          AccessibilityTraits::None)),
-      accessibilityState(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityState",
-          sourceProps.accessibilityState,
-          {})),
-      accessibilityLabel(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityLabel",
-          sourceProps.accessibilityLabel,
-          "")),
-      accessibilityLabelledBy(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityLabelledBy",
-          sourceProps.accessibilityLabelledBy,
-          {})),
-      accessibilityLiveRegion(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityLiveRegion",
-          sourceProps.accessibilityLiveRegion,
-          AccessibilityLiveRegion::None)),
-      accessibilityRole(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityRole",
-          sourceProps.accessibilityRole,
-          "")),
-      accessibilityHint(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityHint",
-          sourceProps.accessibilityHint,
-          "")),
-      accessibilityLanguage(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityLanguage",
-          sourceProps.accessibilityLanguage,
-          "")),
-      accessibilityValue(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityValue",
-          sourceProps.accessibilityValue,
-          {})),
-      accessibilityActions(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityActions",
-          sourceProps.accessibilityActions,
-          {})),
-      accessibilityViewIsModal(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityViewIsModal",
-          sourceProps.accessibilityViewIsModal,
-          false)),
-      accessibilityElementsHidden(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityElementsHidden",
-          sourceProps.accessibilityElementsHidden,
-          false)),
-      accessibilityIgnoresInvertColors(convertRawProp(
-          context,
-          rawProps,
-          "accessibilityIgnoresInvertColors",
-          sourceProps.accessibilityIgnoresInvertColors,
-          false)),
-      onAccessibilityTap(convertRawProp(
-          context,
-          rawProps,
-          "onAccessibilityTap",
-          sourceProps.onAccessibilityTap,
-          {})),
-      onAccessibilityMagicTap(convertRawProp(
-          context,
-          rawProps,
-          "onAccessibilityMagicTap",
-          sourceProps.onAccessibilityMagicTap,
-          {})),
-      onAccessibilityEscape(convertRawProp(
-          context,
-          rawProps,
-          "onAccessibilityEscape",
-          sourceProps.onAccessibilityEscape,
-          {})),
-      onAccessibilityAction(convertRawProp(
-          context,
-          rawProps,
-          "onAccessibilityAction",
-          sourceProps.onAccessibilityAction,
-          {})),
-      importantForAccessibility(convertRawProp(
-          context,
-          rawProps,
-          "importantForAccessibility",
-          sourceProps.importantForAccessibility,
-          ImportantForAccessibility::Auto)),
+    : accessible(
+          enablePropIteratorSetter ? sourceProps.accessible
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessible",
+                                         sourceProps.accessible,
+                                         false)),
+      accessibilityState(
+          enablePropIteratorSetter ? sourceProps.accessibilityState
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityState",
+                                         sourceProps.accessibilityState,
+                                         {})),
+      accessibilityLabel(
+          enablePropIteratorSetter ? sourceProps.accessibilityLabel
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityLabel",
+                                         sourceProps.accessibilityLabel,
+                                         "")),
+      accessibilityLabelledBy(
+          enablePropIteratorSetter ? sourceProps.accessibilityLabelledBy
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityLabelledBy",
+                                         sourceProps.accessibilityLabelledBy,
+                                         {})),
+      accessibilityLiveRegion(
+          enablePropIteratorSetter ? sourceProps.accessibilityLiveRegion
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityLiveRegion",
+                                         sourceProps.accessibilityLiveRegion,
+                                         AccessibilityLiveRegion::None)),
+      accessibilityHint(
+          enablePropIteratorSetter ? sourceProps.accessibilityHint
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityHint",
+                                         sourceProps.accessibilityHint,
+                                         "")),
+      accessibilityLanguage(
+          enablePropIteratorSetter ? sourceProps.accessibilityLanguage
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityLanguage",
+                                         sourceProps.accessibilityLanguage,
+                                         "")),
+      accessibilityValue(
+          enablePropIteratorSetter ? sourceProps.accessibilityValue
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityValue",
+                                         sourceProps.accessibilityValue,
+                                         {})),
+      accessibilityActions(
+          enablePropIteratorSetter ? sourceProps.accessibilityActions
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityActions",
+                                         sourceProps.accessibilityActions,
+                                         {})),
+      accessibilityViewIsModal(
+          enablePropIteratorSetter ? sourceProps.accessibilityViewIsModal
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "accessibilityViewIsModal",
+                                         sourceProps.accessibilityViewIsModal,
+                                         false)),
+      accessibilityElementsHidden(
+          enablePropIteratorSetter
+              ? sourceProps.accessibilityElementsHidden
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "accessibilityElementsHidden",
+                    sourceProps.accessibilityElementsHidden,
+                    false)),
+      accessibilityIgnoresInvertColors(
+          enablePropIteratorSetter
+              ? sourceProps.accessibilityIgnoresInvertColors
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "accessibilityIgnoresInvertColors",
+                    sourceProps.accessibilityIgnoresInvertColors,
+                    false)),
+      onAccessibilityTap(
+          enablePropIteratorSetter ? sourceProps.onAccessibilityTap
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "onAccessibilityTap",
+                                         sourceProps.onAccessibilityTap,
+                                         {})),
+      onAccessibilityMagicTap(
+          enablePropIteratorSetter ? sourceProps.onAccessibilityMagicTap
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "onAccessibilityMagicTap",
+                                         sourceProps.onAccessibilityMagicTap,
+                                         {})),
+      onAccessibilityEscape(
+          enablePropIteratorSetter ? sourceProps.onAccessibilityEscape
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "onAccessibilityEscape",
+                                         sourceProps.onAccessibilityEscape,
+                                         {})),
+      onAccessibilityAction(
+          enablePropIteratorSetter ? sourceProps.onAccessibilityAction
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "onAccessibilityAction",
+                                         sourceProps.onAccessibilityAction,
+                                         {})),
+      importantForAccessibility(
+          enablePropIteratorSetter ? sourceProps.importantForAccessibility
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "importantForAccessibility",
+                                         sourceProps.importantForAccessibility,
+                                         ImportantForAccessibility::Auto)),
       testId(
-          convertRawProp(context, rawProps, "testID", sourceProps.testId, "")) {
+          enablePropIteratorSetter ? sourceProps.testId
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "testID",
+                                         sourceProps.testId,
+                                         "")) {
+  // It is a (severe!) perf deoptimization to request props out-of-order.
+  // Thus, since we need to request the same prop twice here
+  // (accessibilityRole) we "must" do them subsequently here to prevent
+  // a regression. It is reasonable to ask if the `at` function can be improved;
+  // it probably can, but this is a fairly rare edge-case that (1) is easy-ish
+  // to work around here, and (2) would require very careful work to address
+  // this case and not regress the more common cases.
+  if (!enablePropIteratorSetter) {
+    const auto *rawPropValue =
+        rawProps.at("accessibilityRole", nullptr, nullptr);
+    AccessibilityTraits traits;
+    std::string roleString;
+    if (rawPropValue == nullptr || !rawPropValue->hasValue()) {
+      traits = AccessibilityTraits::None;
+      roleString = "";
+    } else {
+      fromRawValue(context, *rawPropValue, traits);
+      fromRawValue(context, *rawPropValue, roleString);
+    }
+    accessibilityTraits = traits;
+    accessibilityRole = roleString;
+  }
+}
+
+void AccessibilityProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  switch (hash) {
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessible, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityState, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLabel, std::string{""});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLabelledBy, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityHint, std::string{""});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLanguage, std::string{""});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityValue, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityActions, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityViewIsModal, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityElementsHidden, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityIgnoresInvertColors, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(onAccessibilityTap, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(onAccessibilityMagicTap, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(onAccessibilityEscape, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(onAccessibilityAction, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(
+        importantForAccessibility, ImportantForAccessibility::Auto);
+    RAW_SET_PROP_SWITCH_CASE(testId, "testID", std::string{""});
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("accessibilityRole"): {
+      AccessibilityTraits traits = AccessibilityTraits::None;
+      std::string roleString = "";
+      if (value.hasValue()) {
+        fromRawValue(context, value, traits);
+        fromRawValue(context, value, roleString);
+      }
+
+      accessibilityTraits = traits;
+      accessibilityRole = roleString;
+      return;
+    }
+  }
 }
 
 #pragma mark - DebugStringConvertible

package/ReactCommon/react/renderer/components/view/AccessibilityProps.h

@@ -24,15 +24,23 @@ class AccessibilityProps {
       AccessibilityProps const &sourceProps,
       RawProps const &rawProps);
 
+  void setProp(
+      const PropsParserContext &context,
+      RawPropsPropNameHash hash,
+      const char *propName,
+      RawValue const &value);
+
+  static bool enablePropIteratorSetter;
+
 #pragma mark - Props
 
   bool accessible{false};
-  AccessibilityTraits accessibilityTraits{AccessibilityTraits::None};
   AccessibilityState accessibilityState;
   std::string accessibilityLabel{""};
   AccessibilityLabelledBy accessibilityLabelledBy{};
   AccessibilityLiveRegion accessibilityLiveRegion{
       AccessibilityLiveRegion::None};
+  AccessibilityTraits accessibilityTraits{AccessibilityTraits::None};
   std::string accessibilityRole{""};
   std::string accessibilityHint{""};
   std::string accessibilityLanguage{""};

package/ReactCommon/react/renderer/components/view/BUCK

@@ -53,7 +53,7 @@ rn_xplat_cxx_library(
     deps = [
         "//third-party/glog:glog",
         "//xplat/fbsystrace:fbsystrace",
-        "//xplat/folly:headers_only",
+        "//xplat/folly:headers_only_do_not_use",
         "//xplat/folly:memory",
         "//xplat/folly:molly",
         YOGA_CXX_TARGET,

package/ReactCommon/react/renderer/components/view/PointerEvent.cpp

@@ -24,8 +24,17 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
       {"pressure", getDebugDescription(pointerEvent.pressure, options)},
       {"pointerType", getDebugDescription(pointerEvent.pointerType, options)},
       {"clientPoint", getDebugDescription(pointerEvent.clientPoint, options)},
-      {"target", getDebugDescription(pointerEvent.target, options)},
-      {"timestamp", getDebugDescription(pointerEvent.timestamp, options)},
+      {"screenPoint", getDebugDescription(pointerEvent.screenPoint, options)},
+      {"offsetPoint", getDebugDescription(pointerEvent.offsetPoint, options)},
+      {"width", getDebugDescription(pointerEvent.width, options)},
+      {"height", getDebugDescription(pointerEvent.height, options)},
+      {"tiltX", getDebugDescription(pointerEvent.tiltX, options)},
+      {"tiltY", getDebugDescription(pointerEvent.tiltY, options)},
+      {"detail", getDebugDescription(pointerEvent.detail, options)},
+      {"buttons", getDebugDescription(pointerEvent.buttons, options)},
+      {"tangentialPressure",
+       getDebugDescription(pointerEvent.tangentialPressure, options)},
+      {"twist", getDebugDescription(pointerEvent.twist, options)},
   };
 }
 

package/ReactCommon/react/renderer/components/view/PointerEvent.h

@@ -35,15 +35,55 @@ struct PointerEvent {
    */
   Point clientPoint;
   /*
-   * A reference to the view to which the event was originally dispatched.
+   * The X/Y coordinate of the pointer in global (screen) coordinates.
    */
-  Tag target;
+  Point screenPoint;
   /*
-   * The time at which the event was created (in milliseconds). By
-   * specification, this value is time since epoch—but in reality, browsers'
-   * definitions vary.
+   * The X/Y coordinate of the pointer relative to the position of the padding
+   * edge of the target node.
    */
-  Float timestamp;
+  Point offsetPoint;
+  /*
+   * The width (magnitude on the X axis), in CSS pixels, of the contact geometry
+   * of the pointer
+   */
+  Float width;
+  /*
+   * The height (magnitude on the y axis), in CSS pixels, of the contact
+   * geometry of the pointer
+   */
+  Float height;
+  /*
+   * The plane angle (in degrees, in the range of -90 to 90) between the Y–Z
+   * plane and the plane containing both the pointer (e.g. pen stylus) axis and
+   * the Y axis.
+   */
+  int tiltX;
+  /*
+   * The plane angle (in degrees, in the range of -90 to 90) between the X–Z
+   * plane and the plane containing both the pointer (e.g. pen stylus) axis and
+   * the X axis.
+   */
+  int tiltY;
+  /*
+   * Returns a long with details about the event, depending on the event type.
+   */
+  int detail;
+  /*
+   * The buttons being depressed (if any) when the mouse event was fired.
+   */
+  int buttons;
+  /*
+   * The normalized tangential pressure of the pointer input (also known as
+   * barrel pressure or cylinder stress) in the range -1 to 1, where 0 is the
+   * neutral position of the control.
+   */
+  Float tangentialPressure;
+  /*
+   * The clockwise rotation of the pointer (e.g. pen stylus) around its major
+   * axis in degrees, with a value in the range 0 to 359.
+   */
+  int twist;
 };
 
 #if RN_DEBUG_STRING_CONVERTIBLE

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

@@ -68,8 +68,25 @@ static jsi::Value pointerEventPayload(
   object.setProperty(runtime, "pointerType", event.pointerType);
   object.setProperty(runtime, "clientX", event.clientPoint.x);
   object.setProperty(runtime, "clientY", event.clientPoint.y);
-  object.setProperty(runtime, "target", event.target);
-  object.setProperty(runtime, "timestamp", event.timestamp * 1000);
+  // x/y are an alias to clientX/Y
+  object.setProperty(runtime, "x", event.clientPoint.x);
+  object.setProperty(runtime, "y", event.clientPoint.y);
+  // since RN doesn't have a scrollable root, pageX/Y will always equal
+  // clientX/Y
+  object.setProperty(runtime, "pageX", event.clientPoint.x);
+  object.setProperty(runtime, "pageY", event.clientPoint.y);
+  object.setProperty(runtime, "screenX", event.screenPoint.x);
+  object.setProperty(runtime, "screenY", event.screenPoint.y);
+  object.setProperty(runtime, "offsetX", event.offsetPoint.x);
+  object.setProperty(runtime, "offsetY", event.offsetPoint.y);
+  object.setProperty(runtime, "width", event.width);
+  object.setProperty(runtime, "height", event.height);
+  object.setProperty(runtime, "tiltX", event.tiltX);
+  object.setProperty(runtime, "tiltY", event.tiltY);
+  object.setProperty(runtime, "detail", event.detail);
+  object.setProperty(runtime, "buttons", event.buttons);
+  object.setProperty(runtime, "tangentialPressure", event.tangentialPressure);
+  object.setProperty(runtime, "twist", event.twist);
   return object;
 }
 
@@ -147,8 +164,8 @@ void TouchEventEmitter::onPointerDown(const PointerEvent &event) const {
       RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onPointerMove2(const PointerEvent &event) const {
-  dispatchUniqueEvent("pointerMove2", [event](jsi::Runtime &runtime) {
+void TouchEventEmitter::onPointerMove(const PointerEvent &event) const {
+  dispatchUniqueEvent("pointerMove", [event](jsi::Runtime &runtime) {
     return pointerEventPayload(runtime, event);
   });
 }
@@ -161,21 +178,37 @@ void TouchEventEmitter::onPointerUp(const PointerEvent &event) const {
       RawEvent::Category::ContinuousEnd);
 }
 
-void TouchEventEmitter::onPointerEnter2(const PointerEvent &event) const {
+void TouchEventEmitter::onPointerEnter(const PointerEvent &event) const {
   dispatchPointerEvent(
-      "pointerEnter2",
+      "pointerEnter",
       event,
       EventPriority::AsynchronousBatched,
       RawEvent::Category::ContinuousStart);
 }
 
-void TouchEventEmitter::onPointerLeave2(const PointerEvent &event) const {
+void TouchEventEmitter::onPointerLeave(const PointerEvent &event) const {
   dispatchPointerEvent(
-      "pointerLeave2",
+      "pointerLeave",
       event,
       EventPriority::AsynchronousBatched,
       RawEvent::Category::ContinuousEnd);
 }
 
+void TouchEventEmitter::onPointerOver(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerOver",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onPointerOut(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerOut",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
 } // namespace react
 } // namespace facebook

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

@@ -32,10 +32,12 @@ class TouchEventEmitter : public EventEmitter {
 
   void onPointerCancel(PointerEvent const &event) const;
   void onPointerDown(PointerEvent const &event) const;
-  void onPointerMove2(PointerEvent const &event) const;
+  void onPointerMove(PointerEvent const &event) const;
   void onPointerUp(PointerEvent const &event) const;
-  void onPointerEnter2(PointerEvent const &event) const;
-  void onPointerLeave2(PointerEvent const &event) const;
+  void onPointerEnter(PointerEvent const &event) const;
+  void onPointerLeave(PointerEvent const &event) const;
+  void onPointerOver(PointerEvent const &event) const;
+  void onPointerOut(PointerEvent const &event) const;
 
  private:
   void dispatchTouchEvent(