react-native 0.0.0-17be3a003 → 0.0.0-18697adec

package/ReactCommon/react/renderer/components/textinput/iostextinput/propsConversions.h

@@ -8,107 +8,135 @@
 #pragma once
 
 #include <react/renderer/components/iostextinput/primitives.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/propsConversions.h>
 
 namespace facebook {
 namespace react {
 
 static TextInputTraits convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     TextInputTraits const &sourceTraits,
     TextInputTraits const &defaultTraits) {
   auto traits = TextInputTraits{};
 
   traits.multiline = convertRawProp(
-      rawProps, "multiline", sourceTraits.multiline, defaultTraits.multiline);
+      context,
+      rawProps,
+      "multiline",
+      sourceTraits.multiline,
+      defaultTraits.multiline);
   traits.autocapitalizationType = convertRawProp(
+      context,
       rawProps,
       "autoCapitalize",
       sourceTraits.autocapitalizationType,
       defaultTraits.autocapitalizationType);
   traits.autoCorrect = convertRawProp(
+      context,
       rawProps,
       "autoCorrect",
       sourceTraits.autoCorrect,
       defaultTraits.autoCorrect);
   traits.contextMenuHidden = convertRawProp(
+      context,
       rawProps,
       "contextMenuHidden",
       sourceTraits.contextMenuHidden,
       defaultTraits.contextMenuHidden);
   traits.editable = convertRawProp(
-      rawProps, "editable", sourceTraits.editable, defaultTraits.editable);
+      context,
+      rawProps,
+      "editable",
+      sourceTraits.editable,
+      defaultTraits.editable);
   traits.enablesReturnKeyAutomatically = convertRawProp(
+      context,
       rawProps,
       "enablesReturnKeyAutomatically",
       sourceTraits.enablesReturnKeyAutomatically,
       defaultTraits.enablesReturnKeyAutomatically);
   traits.keyboardAppearance = convertRawProp(
+      context,
       rawProps,
       "keyboardAppearance",
       sourceTraits.keyboardAppearance,
       defaultTraits.keyboardAppearance);
   traits.spellCheck = convertRawProp(
+      context,
       rawProps,
       "spellCheck",
       sourceTraits.spellCheck,
       defaultTraits.spellCheck);
   traits.caretHidden = convertRawProp(
+      context,
       rawProps,
       "caretHidden",
       sourceTraits.caretHidden,
       defaultTraits.caretHidden);
   traits.clearButtonMode = convertRawProp(
+      context,
       rawProps,
       "clearButtonMode",
       sourceTraits.clearButtonMode,
       defaultTraits.clearButtonMode);
   traits.scrollEnabled = convertRawProp(
+      context,
       rawProps,
       "scrollEnabled",
       sourceTraits.scrollEnabled,
       defaultTraits.scrollEnabled);
   traits.secureTextEntry = convertRawProp(
+      context,
       rawProps,
       "secureTextEntry",
       sourceTraits.secureTextEntry,
       defaultTraits.secureTextEntry);
   traits.blurOnSubmit = convertRawProp(
+      context,
       rawProps,
       "blurOnSubmit",
       sourceTraits.blurOnSubmit,
       defaultTraits.blurOnSubmit);
   traits.clearTextOnFocus = convertRawProp(
+      context,
       rawProps,
       "clearTextOnFocus",
       sourceTraits.clearTextOnFocus,
       defaultTraits.clearTextOnFocus);
   traits.keyboardType = convertRawProp(
+      context,
       rawProps,
       "keyboardType",
       sourceTraits.keyboardType,
       defaultTraits.keyboardType);
   traits.showSoftInputOnFocus = convertRawProp(
+      context,
       rawProps,
       "showSoftInputOnFocus",
       sourceTraits.showSoftInputOnFocus,
       defaultTraits.showSoftInputOnFocus);
   traits.returnKeyType = convertRawProp(
+      context,
       rawProps,
       "returnKeyType",
       sourceTraits.returnKeyType,
       defaultTraits.returnKeyType);
   traits.selectTextOnFocus = convertRawProp(
+      context,
       rawProps,
       "selectTextOnFocus",
       sourceTraits.selectTextOnFocus,
       defaultTraits.selectTextOnFocus);
   traits.textContentType = convertRawProp(
+      context,
       rawProps,
       "textContentType",
       sourceTraits.textContentType,
       defaultTraits.textContentType);
   traits.passwordRules = convertRawProp(
+      context,
       rawProps,
       "passwordRules",
       sourceTraits.passwordRules,
@@ -117,5 +145,38 @@ static TextInputTraits convertRawProp(
   return traits;
 }
 
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    Selection &result) {
+  if (value.hasType<better::map<std::string, int>>()) {
+    auto map = (better::map<std::string, int>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "start") {
+        result.start = pair.second;
+      } else if (pair.first == "end") {
+        result.end = pair.second;
+      } else {
+        LOG(ERROR) << "Unsupported Selection map key: " << pair.first;
+        react_native_assert(false);
+      }
+    }
+    return;
+  }
+
+  react_native_assert(value.hasType<std::vector<int>>());
+  if (value.hasType<std::vector<int>>()) {
+    auto array = (std::vector<int>)value;
+    react_native_assert(array.size() == 2);
+    if (array.size() >= 2) {
+      result = {array.at(0), array.at(1)};
+    } else {
+      result = {0, 0};
+      LOG(ERROR) << "Unsupported Selection vector size: " << array.size();
+    }
+  } else {
+    LOG(ERROR) << "Unsupported Selection type";
+  }
+}
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/components/unimplementedview/Android.mk

@@ -21,7 +21,7 @@ LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
 
 LOCAL_STATIC_LIBRARIES :=
 
-LOCAL_SHARED_LIBRARIES := libyoga libfolly_futures glog libfolly_json libglog_init libreact_render_core libreact_render_debug libreact_render_graphics librrc_view libreact_debug
+LOCAL_SHARED_LIBRARIES := libjsi libyoga libfolly_futures glog libfolly_json libglog_init libreact_render_core libreact_render_debug libreact_render_graphics librrc_view libreact_debug
 
 include $(BUILD_SHARED_LIBRARY)
 

package/ReactCommon/react/renderer/components/unimplementedview/UnimplementedViewComponentDescriptor.cpp

@@ -22,19 +22,21 @@ ComponentName UnimplementedViewComponentDescriptor::getComponentName() const {
 }
 
 Props::Shared UnimplementedViewComponentDescriptor::cloneProps(
+    PropsParserContext const &context,
     Props::Shared const &props,
     RawProps const &rawProps) const {
   auto clonedProps =
       ConcreteComponentDescriptor<UnimplementedViewShadowNode>::cloneProps(
-          props, rawProps);
+          context, props, rawProps);
   react_native_assert(
       std::dynamic_pointer_cast<UnimplementedViewProps const>(clonedProps));
 
   // We have to clone `Props` object one more time to make sure that we have
   // an unshared (and non-`const`) copy of it which we can mutate.
   RawProps emptyRawProps{};
-  emptyRawProps.parse(rawPropsParser_);
+  emptyRawProps.parse(rawPropsParser_, context);
   auto unimplementedViewProps = std::make_shared<UnimplementedViewProps>(
+      context,
       *std::static_pointer_cast<UnimplementedViewProps const>(clonedProps),
       emptyRawProps);
 

package/ReactCommon/react/renderer/components/unimplementedview/UnimplementedViewComponentDescriptor.h

@@ -9,6 +9,7 @@
 
 #include <react/renderer/components/unimplementedview/UnimplementedViewShadowNode.h>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
 
 namespace facebook {
 namespace react {
@@ -32,8 +33,10 @@ class UnimplementedViewComponentDescriptor final
    * In addtion to base implementation, stores a component name inside cloned
    * `Props` object.
    */
-  Props::Shared cloneProps(Props::Shared const &props, RawProps const &rawProps)
-      const override;
+  Props::Shared cloneProps(
+      PropsParserContext const &context,
+      Props::Shared const &props,
+      RawProps const &rawProps) const override;
 };
 
 } // namespace react

package/ReactCommon/react/renderer/components/unimplementedview/UnimplementedViewProps.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
 
 namespace facebook {
 namespace react {

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

@@ -7,7 +7,9 @@
 
 #pragma once
 
+#include <better/optional.h>
 #include <cinttypes>
+#include <string>
 
 namespace facebook {
 namespace react {
@@ -31,6 +33,7 @@ enum class AccessibilityTraits : uint32_t {
   CausesPageTurn = (1 << 14),
   Header = (1 << 15),
   Switch = (1 << 16),
+  TabBar = (1 << 17),
 };
 
 constexpr enum AccessibilityTraits operator|(
@@ -45,6 +48,11 @@ constexpr enum AccessibilityTraits operator&(
   return (enum AccessibilityTraits)((uint32_t)lhs & (uint32_t)rhs);
 }
 
+struct AccessibilityAction {
+  std::string name{""};
+  better::optional<std::string> label{};
+};
+
 struct AccessibilityState {
   bool disabled{false};
   bool selected{false};
@@ -67,6 +75,26 @@ constexpr bool operator!=(
   return !(rhs == lhs);
 }
 
+struct AccessibilityValue {
+  better::optional<int> min;
+  better::optional<int> max;
+  better::optional<int> now;
+  better::optional<std::string> text{};
+};
+
+constexpr bool operator==(
+    AccessibilityValue const &lhs,
+    AccessibilityValue const &rhs) {
+  return lhs.min == rhs.min && lhs.max == rhs.max && lhs.now == rhs.now &&
+      lhs.text == rhs.text;
+}
+
+constexpr bool operator!=(
+    AccessibilityValue const &lhs,
+    AccessibilityValue const &rhs) {
+  return !(rhs == lhs);
+}
+
 enum class ImportantForAccessibility {
   Auto,
   Yes,

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

@@ -16,79 +16,102 @@ namespace facebook {
 namespace react {
 
 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,
           "")),
       accessibilityHint(convertRawProp(
+          context,
           rawProps,
           "accessibilityHint",
           sourceProps.accessibilityHint,
           "")),
+      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)),
-      testId(convertRawProp(rawProps, "testID", sourceProps.testId, "")) {}
+      testId(
+          convertRawProp(context, rawProps, "testID", sourceProps.testId, "")) {
+}
 
 #pragma mark - DebugStringConvertible
 

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

@@ -9,6 +9,7 @@
 
 #include <react/renderer/components/view/AccessibilityPrimitives.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
 
@@ -19,6 +20,7 @@ class AccessibilityProps {
  public:
   AccessibilityProps() = default;
   AccessibilityProps(
+      const PropsParserContext &context,
       AccessibilityProps const &sourceProps,
       RawProps const &rawProps);
 
@@ -29,7 +31,8 @@ class AccessibilityProps {
   AccessibilityState accessibilityState;
   std::string accessibilityLabel{""};
   std::string accessibilityHint{""};
-  std::vector<std::string> accessibilityActions{};
+  AccessibilityValue accessibilityValue;
+  std::vector<AccessibilityAction> accessibilityActions{};
   bool accessibilityViewIsModal{false};
   bool accessibilityElementsHidden{false};
   bool accessibilityIgnoresInvertColors{false};

package/ReactCommon/react/renderer/components/view/Android.mk

@@ -11,7 +11,7 @@ LOCAL_MODULE := rrc_view
 
 LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
 
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../../
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../../../
 
 LOCAL_CFLAGS := \
@@ -21,7 +21,7 @@ LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
 
 LOCAL_STATIC_LIBRARIES :=
 
-LOCAL_SHARED_LIBRARIES := libyoga glog libfolly_json libglog_init libreact_render_core libreact_render_debug libreact_render_graphics libreact_debug
+LOCAL_SHARED_LIBRARIES := libyoga glog libfolly_json libglog_init libreact_render_core libreact_render_debug libreact_render_graphics libreact_debug logger libjsi
 
 include $(BUILD_SHARED_LIBRARY)
 
@@ -31,5 +31,6 @@ $(call import-module,fbgloginit)
 $(call import-module,react/renderer/core)
 $(call import-module,react/renderer/debug)
 $(call import-module,react/renderer/graphics)
+$(call import-module,logger)
 $(call import-module,yogajni)
 $(call import-module,react/debug)

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

@@ -64,6 +64,7 @@ rn_xplat_cxx_library(
         react_native_xplat_target("react/renderer/core:core"),
         react_native_xplat_target("react/renderer/debug:debug"),
         react_native_xplat_target("react/renderer/graphics:graphics"),
+        react_native_xplat_target("logger:logger"),
     ],
 )
 

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

@@ -52,38 +52,7 @@ struct Touch {
   Float force;
 
   /*
-   * The time in seconds (with fractional milliseconds) when the touch occurred
-   * or when it was last mutated.
-   *
-   * Whenever possible this should be computed as:
-   * 1. Pick MONO_CLOCK_NOW, a monotonic system clock. Generally, something like
-   * `systemUptimeMillis`.
-   * 2. BASIS_TIME = unix timestamp from unix epoch (ms) - MONO_CLOCK_NOW
-   * 3. Then assign timestamp = BASIS_TIME + MONO_CLOCK_NOW
-   *
-   * The effect should be UNIX timestamp from UNIX epoch, but as a monotonic
-   * clock (if you just assign to current system time, it can move backwards due
-   * to clock adjustements, leap seconds, etc etc). So the vast majority of the
-   * time it will look identical to current UNIX time, but there are some
-   * edge-cases where it can drift.
-   *
-   * If you are not able to use the scheme above for some reason, prefer to use
-   * a monotonic clock. This timestamp MUST be monotonic. Do NOT just pass along
-   * system time.
-   *
-   * The goal is to allow touch latency to be computed in JS. JS does not have
-   * access to something like `systemUptimeMillis`, it generally can only access
-   * the current system time. This *does* mean that the touch latency could be
-   * computed incorrectly in cases of clock drift, so you should only use this
-   * as telemetry to get a decent, but not totally perfect, idea of performance.
-   * Do not use this latency information for anything "mission critical". You
-   * can assume it's probably reasonably accurate 99% of the time.
-   *
-   * Note that we attempt to adhere to the spec of timestamp here:
-   * https://dom.spec.whatwg.org/#dom-event-timestamp
-   * Notably, since `global` is not a Window object in React Native, we have
-   * some flexibility in how we define the time origin:
-   * https://w3c.github.io/hr-time/#dfn-time-origin
+   * The time in seconds when the touch occurred or when it was last mutated.
    */
   Float timestamp;
 

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

@@ -62,17 +62,23 @@ static jsi::Value touchEventPayload(
 void TouchEventEmitter::dispatchTouchEvent(
     std::string const &type,
     TouchEvent const &event,
-    EventPriority const &priority) const {
+    EventPriority priority,
+    RawEvent::Category category) const {
   dispatchEvent(
       type,
       [event](jsi::Runtime &runtime) {
         return touchEventPayload(runtime, event);
       },
-      priority);
+      priority,
+      category);
 }
 
 void TouchEventEmitter::onTouchStart(TouchEvent const &event) const {
-  dispatchTouchEvent("touchStart", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchStart",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
 }
 
 void TouchEventEmitter::onTouchMove(TouchEvent const &event) const {
@@ -82,11 +88,19 @@ void TouchEventEmitter::onTouchMove(TouchEvent const &event) const {
 }
 
 void TouchEventEmitter::onTouchEnd(TouchEvent const &event) const {
-  dispatchTouchEvent("touchEnd", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchEnd",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
 }
 
 void TouchEventEmitter::onTouchCancel(TouchEvent const &event) const {
-  dispatchTouchEvent("touchCancel", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchCancel",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
 }
 
 } // namespace react

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

@@ -33,7 +33,8 @@ class TouchEventEmitter : public EventEmitter {
   void dispatchTouchEvent(
       std::string const &type,
       TouchEvent const &event,
-      EventPriority const &priority) const;
+      EventPriority priority,
+      RawEvent::Category category) const;
 };
 
 } // namespace react

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

@@ -9,8 +9,6 @@
 
 #include <react/renderer/components/view/ViewShadowNode.h>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
-#include "ViewProps.h"
-#include "ViewPropsInterpolation.h"
 
 namespace facebook {
 namespace react {
@@ -20,26 +18,6 @@ class ViewComponentDescriptor
  public:
   ViewComponentDescriptor(ComponentDescriptorParameters const &parameters)
       : ConcreteComponentDescriptor<ViewShadowNode>(parameters) {}
-
-  virtual SharedProps interpolateProps(
-      float animationProgress,
-      const SharedProps &props,
-      const SharedProps &newProps) const override {
-#ifdef ANDROID
-    // On Android only, the merged props should have the same RawProps as the
-    // final props struct
-    SharedProps interpolatedPropsShared =
-        (newProps != nullptr ? cloneProps(newProps, newProps->rawProps)
-                             : cloneProps(newProps, {}));
-#else
-    SharedProps interpolatedPropsShared = cloneProps(newProps, {});
-#endif
-
-    interpolateViewProps(
-        animationProgress, props, newProps, interpolatedPropsShared);
-
-    return interpolatedPropsShared;
-  };
 };
 
 } // namespace react

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

@@ -15,7 +15,7 @@ namespace react {
 void ViewEventEmitter::onAccessibilityAction(const std::string &name) const {
   dispatchEvent("accessibilityAction", [name](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);
-    payload.setProperty(runtime, "action", name);
+    payload.setProperty(runtime, "actionName", name);
     return payload;
   });
 }