react-native 0.0.0-263478b91 → 0.0.0-268efb102

package/ReactCommon/react/renderer/core/RawEvent.h

@@ -19,16 +19,53 @@ namespace react {
 /*
  * Represents ready-to-dispatch event object.
  */
-class RawEvent {
- public:
+struct RawEvent {
+  /*
+   * Defines category of a native platform event. This is used to deduce types
+   * of events for Concurrent Mode.
+   */
+  enum class Category {
+    /*
+     * Start of a continuous event. To be used with touchStart.
+     */
+    ContinuousStart,
+
+    /*
+     * End of a continuous event. To be used with touchEnd.
+     */
+    ContinuousEnd,
+
+    /*
+     * Priority for this event will be determined from other events in the
+     * queue. If it is triggered by continuous event, its priority will be
+     * default. If it is not triggered by continuous event, its priority will be
+     * discrete.
+     */
+    Unspecified,
+
+    /*
+     * Forces discrete type for the event. Regardless if continuous event is
+     * ongoing.
+     */
+    Discrete,
+
+    /*
+     * Forces continuous type for the event. Regardless if continuous event
+     * isn't ongoing.
+     */
+    Continuous
+  };
+
   RawEvent(
       std::string type,
       ValueFactory payloadFactory,
-      SharedEventTarget eventTarget);
+      SharedEventTarget eventTarget,
+      Category category = Category::Unspecified);
 
   std::string type;
   ValueFactory payloadFactory;
   SharedEventTarget eventTarget;
+  Category category;
 };
 
 } // namespace react

package/ReactCommon/react/renderer/core/RawProps.cpp

@@ -47,7 +47,8 @@ RawProps::RawProps(folly::dynamic const &dynamic) noexcept {
   dynamic_ = dynamic;
 }
 
-void RawProps::parse(RawPropsParser const &parser) const noexcept {
+void RawProps::parse(RawPropsParser const &parser, const PropsParserContext &)
+    const noexcept {
   react_native_assert(parser_ == nullptr && "A parser was already assigned.");
   parser_ = &parser;
   parser.preparse(*this);

package/ReactCommon/react/renderer/core/RawProps.h

@@ -16,6 +16,7 @@
 #include <folly/dynamic.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsPrimitives.h>
 #include <react/renderer/core/RawValue.h>
@@ -74,7 +75,8 @@ class RawProps final {
   RawProps(RawProps const &other) noexcept = delete;
   RawProps &operator=(RawProps const &other) noexcept = delete;
 
-  void parse(RawPropsParser const &parser) const noexcept;
+  void parse(RawPropsParser const &parser, const PropsParserContext &)
+      const noexcept;
 
   /*
    * Deprecated. Do not use.

package/ReactCommon/react/renderer/core/RawPropsKey.cpp

@@ -51,10 +51,18 @@ RawPropsKey::operator std::string() const noexcept {
   return std::string{buffer, length};
 }
 
+static bool areFieldsEqual(char const *lhs, char const *rhs) {
+  if (lhs == nullptr || rhs == nullptr) {
+    return lhs == rhs;
+  }
+  return std::string(lhs) == std::string(rhs);
+}
+
 bool operator==(RawPropsKey const &lhs, RawPropsKey const &rhs) noexcept {
   // Note: We check the name first.
-  return lhs.name == rhs.name && lhs.prefix == rhs.prefix &&
-      lhs.suffix == rhs.suffix;
+  return areFieldsEqual(lhs.name, rhs.name) &&
+      areFieldsEqual(lhs.prefix, rhs.prefix) &&
+      areFieldsEqual(lhs.suffix, rhs.suffix);
 }
 
 bool operator!=(RawPropsKey const &lhs, RawPropsKey const &rhs) noexcept {

package/ReactCommon/react/renderer/core/RawPropsKeyMap.cpp

@@ -63,7 +63,7 @@ void RawPropsKeyMap::reindex() noexcept {
   buckets_.resize(kPropNameLengthHardCap);
 
   auto length = RawPropsPropNameLength{0};
-  for (auto i = 0; i < items_.size(); i++) {
+  for (size_t i = 0; i < items_.size(); i++) {
     auto &item = items_[i];
     if (item.length != length) {
       for (auto j = length; j < item.length; j++) {

package/ReactCommon/react/renderer/core/RawPropsParser.cpp

@@ -114,7 +114,7 @@ void RawPropsParser::preparse(RawProps const &rawProps) const noexcept {
       auto count = names.size(runtime);
       auto valueIndex = RawPropsValueIndex{0};
 
-      for (auto i = 0; i < count; i++) {
+      for (size_t i = 0; i < count; i++) {
         auto nameValue = names.getValueAtIndex(runtime, i).getString(runtime);
         auto value = object.getProperty(runtime, nameValue);
 

package/ReactCommon/react/renderer/core/RawPropsParser.h

@@ -10,6 +10,7 @@
 #include <better/map.h>
 #include <better/small_vector.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsKeyMap.h>
@@ -40,8 +41,16 @@ class RawPropsParser final {
         std::is_base_of<Props, PropsT>::value,
         "PropsT must be a descendant of Props");
     RawProps emptyRawProps{};
-    emptyRawProps.parse(*this);
-    PropsT({}, emptyRawProps);
+
+    // Create a stub parser context.
+    // Since this prepares the parser by passing in
+    // empty props, no prop parsers should actually reference the
+    // ContextContainer or SurfaceId here.
+    ContextContainer contextContainer{};
+    PropsParserContext parserContext{-1, contextContainer};
+
+    emptyRawProps.parse(*this, parserContext);
+    PropsT(parserContext, {}, emptyRawProps);
     postPrepare();
   }
 

package/ReactCommon/react/renderer/core/ReactEventPriority.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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
+
+namespace facebook {
+namespace react {
+
+/*
+ * An enum that represents React's event priority.
+ * Used to map Fabric events to React.
+ */
+enum class ReactEventPriority {
+  /*
+   * Event priority is unspecified.
+   */
+  Default,
+
+  /*
+   * User events that happen at discrete times, like
+   * input into text field.
+   */
+  Discrete,
+
+  /*
+   * “fluid” user events that happen many times over a short period of time like
+   * scrolling.
+   */
+  Continuous,
+};
+
+static constexpr std::underlying_type<ReactEventPriority>::type serialize(
+    ReactEventPriority reactEventPriority) {
+  return static_cast<std::underlying_type<ReactEventPriority>::type>(
+      reactEventPriority);
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/core/ReactPrimitives.h

@@ -8,8 +8,6 @@
 #pragma once
 
 #include <folly/dynamic.h>
-#include <react/renderer/core/RawProps.h>
-#include <react/renderer/core/RawValue.h>
 #include <memory>
 #include <string>
 

package/ReactCommon/react/renderer/core/ShadowNode.cpp

@@ -6,7 +6,6 @@
  */
 
 #include "ShadowNode.h"
-#include "Constants.h"
 #include "DynamicPropsUtilities.h"
 #include "ShadowNodeFragment.h"
 
@@ -39,15 +38,13 @@ SharedProps ShadowNode::propsForClonedShadowNode(
     ShadowNode const &sourceShadowNode,
     Props::Shared const &props) {
 #ifdef ANDROID
-  if (Constants::getPropsForwardingEnabled()) {
-    bool hasBeenMounted = sourceShadowNode.hasBeenMounted_;
-    bool sourceNodeHasRawProps = !sourceShadowNode.getProps()->rawProps.empty();
-    if (!hasBeenMounted && sourceNodeHasRawProps && props) {
-      auto &castedProps = const_cast<Props &>(*props);
-      castedProps.rawProps = mergeDynamicProps(
-          sourceShadowNode.getProps()->rawProps, props->rawProps);
-      return props;
-    }
+  bool hasBeenMounted = sourceShadowNode.hasBeenMounted_;
+  bool sourceNodeHasRawProps = !sourceShadowNode.getProps()->rawProps.empty();
+  if (!hasBeenMounted && sourceNodeHasRawProps && props) {
+    auto &castedProps = const_cast<Props &>(*props);
+    castedProps.rawProps = mergeDynamicProps(
+        sourceShadowNode.getProps()->rawProps, props->rawProps);
+    return props;
   }
 #endif
   return props ? props : sourceShadowNode.getProps();
@@ -213,7 +210,7 @@ void ShadowNode::replaceChild(
       *std::const_pointer_cast<ShadowNode::ListOfShared>(children_);
   auto size = children.size();
 
-  if (suggestedIndex != -1 && suggestedIndex < size) {
+  if (suggestedIndex != -1 && static_cast<size_t>(suggestedIndex) < size) {
     // If provided `suggestedIndex` is accurate,
     // replacing in place using the index.
     if (children.at(suggestedIndex).get() == &oldChild) {
@@ -222,7 +219,7 @@ void ShadowNode::replaceChild(
     }
   }
 
-  for (auto index = 0; index < size; index++) {
+  for (size_t index = 0; index < size; index++) {
     if (children.at(index).get() == &oldChild) {
       children[index] = newChild;
       return;

package/ReactCommon/react/renderer/core/ShadowNode.h

@@ -240,5 +240,9 @@ ShadowNodeReferenceT traitCast(ShadowNode const &shadowNode);
 template <typename ShadowNodePointerT>
 ShadowNodePointerT traitCast(ShadowNode const *shadowNode);
 
+template <typename ShadowNodePointerT>
+std::shared_ptr<ShadowNodePointerT const> traitCast(
+    std::shared_ptr<ShadowNode const> shadowNode);
+
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/core/ShadowNodeFamily.h

@@ -10,6 +10,7 @@
 #include <memory>
 
 #include <better/mutex.h>
+#include <better/small_vector.h>
 
 #include <react/renderer/core/EventEmitter.h>
 #include <react/renderer/core/ReactPrimitives.h>

package/ReactCommon/react/renderer/core/ShadowNodeTraits.h

@@ -21,7 +21,7 @@ class ShadowNodeTraits {
  public:
   /*
    * Underlying type for the traits.
-   * The first 16 bits are reserved for Core.
+   * The first 23 bits are reserved for Core.
    */
   enum Trait : int32_t {
     None = 0,
@@ -82,6 +82,22 @@ class ShadowNodeTraits {
     // Indicates that `children` list is shared between nodes and need
     // to be cloned before the first mutation.
     ChildrenAreShared = 1 << 15,
+
+    // Inherits 'RawTextShadowNode'
+    RawText = 1 << 16,
+
+    // Inherits 'TextShadowNode'
+    Text = 1 << 17,
+
+    // Reserved
+    ReservedTrait1 = 1 << 18,
+    ReservedTrait2 = 1 << 19,
+    ReservedTrait3 = 1 << 20,
+    ReservedTrait4 = 1 << 21,
+    ReservedTrait5 = 1 << 22,
+
+    // Unserved - alias these for local usage
+    UnreservedTrait1 = 1 << 23
   };
 
   /*

package/ReactCommon/react/renderer/core/propsConversions.h

@@ -10,6 +10,7 @@
 #include <better/optional.h>
 #include <folly/Likely.h>
 #include <folly/dynamic.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Geometry.h>
@@ -19,20 +20,26 @@ namespace facebook {
 namespace react {
 
 template <typename T>
-void fromRawValue(RawValue const &rawValue, T &result) {
+void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    T &result) {
   result = (T)rawValue;
 }
 
 template <typename T>
-void fromRawValue(RawValue const &rawValue, std::vector<T> &result) {
+void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    std::vector<T> &result) {
   if (rawValue.hasType<std::vector<RawValue>>()) {
     auto items = (std::vector<RawValue>)rawValue;
     auto length = items.size();
     result.clear();
     result.reserve(length);
-    for (int i = 0; i < length; i++) {
+    for (size_t i = 0; i < length; i++) {
       T itemResult;
-      fromRawValue(items.at(i), itemResult);
+      fromRawValue(context, items.at(i), itemResult);
       result.push_back(itemResult);
     }
     return;
@@ -42,12 +49,13 @@ void fromRawValue(RawValue const &rawValue, std::vector<T> &result) {
   result.clear();
   result.reserve(1);
   T itemResult;
-  fromRawValue(rawValue, itemResult);
+  fromRawValue(context, rawValue, itemResult);
   result.push_back(itemResult);
 }
 
 template <typename T>
 void fromRawValue(
+    const PropsParserContext &context,
     RawValue const &rawValue,
     std::vector<std::vector<T>> &result) {
   if (rawValue.hasType<std::vector<std::vector<RawValue>>>()) {
@@ -57,7 +65,7 @@ void fromRawValue(
     result.reserve(length);
     for (int i = 0; i < length; i++) {
       T itemResult;
-      fromRawValue(items.at(i), itemResult);
+      fromRawValue(context, items.at(i), itemResult);
       result.push_back(itemResult);
     }
     return;
@@ -67,12 +75,13 @@ void fromRawValue(
   result.clear();
   result.reserve(1);
   T itemResult;
-  fromRawValue(rawValue, itemResult);
+  fromRawValue(context, rawValue, itemResult);
   result.push_back(itemResult);
 }
 
 template <typename T, typename U = T>
 T convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     char const *name,
     T const &sourceValue,
@@ -92,12 +101,13 @@ T convertRawProp(
   }
 
   T result;
-  fromRawValue(*rawValue, result);
+  fromRawValue(context, *rawValue, result);
   return result;
 }
 
 template <typename T>
 static better::optional<T> convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     char const *name,
     better::optional<T> const &sourceValue,
@@ -117,7 +127,7 @@ static better::optional<T> convertRawProp(
   }
 
   T result;
-  fromRawValue(*rawValue, result);
+  fromRawValue(context, *rawValue, result);
   return better::optional<T>{result};
 }
 

package/ReactCommon/react/renderer/core/tests/ComponentDescriptorTest.cpp

@@ -7,6 +7,8 @@
 
 #include <gtest/gtest.h>
 
+#include <react/renderer/core/PropsParserContext.h>
+
 #include "TestComponent.h"
 
 using namespace facebook::react;
@@ -21,8 +23,11 @@ TEST(ComponentDescriptorTest, createShadowNode) {
   EXPECT_STREQ(descriptor->getComponentName(), TestShadowNode::Name());
   EXPECT_STREQ(descriptor->getComponentName(), "Test");
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
 
   auto family = descriptor->createFamily(
       ShadowNodeFamilyFragment{
@@ -52,8 +57,11 @@ TEST(ComponentDescriptorTest, cloneShadowNode) {
       std::make_shared<TestComponentDescriptor>(
           ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr});
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
   auto family = descriptor->createFamily(
       ShadowNodeFamilyFragment{
           /* .tag = */ 9,
@@ -73,7 +81,8 @@ TEST(ComponentDescriptorTest, cloneShadowNode) {
   EXPECT_EQ(cloned->getSurfaceId(), 1);
   EXPECT_STREQ(cloned->getProps()->nativeId.c_str(), "abc");
 
-  auto clonedButSameProps = descriptor->cloneProps(props, RawProps());
+  auto clonedButSameProps =
+      descriptor->cloneProps(parserContext, props, RawProps());
   EXPECT_NE(clonedButSameProps, props);
 }
 
@@ -83,8 +92,11 @@ TEST(ComponentDescriptorTest, appendChild) {
       std::make_shared<TestComponentDescriptor>(
           ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr});
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
   auto family1 = descriptor->createFamily(
       ShadowNodeFamilyFragment{
           /* .tag = */ 1,

package/ReactCommon/react/renderer/core/tests/EventQueueProcessorTest.cpp

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+#include <hermes/API/hermes/hermes.h>
+#include <jsi/jsi.h>
+#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
+#include <react/renderer/core/StatePipe.h>
+
+#include <memory>
+
+namespace facebook::react {
+
+class EventQueueProcessorTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    runtime_ = facebook::hermes::makeHermesRuntime();
+
+    auto eventPipe = [this](
+                         jsi::Runtime &runtime,
+                         const EventTarget *eventTarget,
+                         const std::string &type,
+                         ReactEventPriority priority,
+                         const ValueFactory &payloadFactory) {
+      eventTypes_.push_back(type);
+      eventPriorities_.push_back(priority);
+    };
+
+    auto dummyStatePipe = [](StateUpdate const &stateUpdate) {};
+
+    eventProcessor_ =
+        std::make_unique<EventQueueProcessor>(eventPipe, dummyStatePipe);
+  }
+
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  std::unique_ptr<EventQueueProcessor> eventProcessor_;
+  std::vector<std::string> eventTypes_;
+  std::vector<ReactEventPriority> eventPriorities_;
+  ValueFactory dummyValueFactory_;
+};
+
+TEST_F(EventQueueProcessorTest, singleUnspecifiedEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {RawEvent(
+          "my type",
+          dummyValueFactory_,
+          nullptr,
+          RawEvent::Category::Unspecified)});
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+  EXPECT_EQ(eventTypes_[0], "my type");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+}
+
+TEST_F(EventQueueProcessorTest, continiousEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {RawEvent(
+           "touchStart",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::ContinuousStart),
+       RawEvent(
+           "touchMove",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::Unspecified),
+       RawEvent(
+           "touchEnd",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::ContinuousEnd),
+       RawEvent(
+           "custom event",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::Unspecified)});
+
+  EXPECT_EQ(eventPriorities_.size(), 4);
+
+  EXPECT_EQ(eventTypes_[0], "touchStart");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+
+  EXPECT_EQ(eventTypes_[1], "touchMove");
+  EXPECT_EQ(eventPriorities_[1], ReactEventPriority::Default);
+
+  EXPECT_EQ(eventTypes_[2], "touchEnd");
+  EXPECT_EQ(eventPriorities_[2], ReactEventPriority::Discrete);
+
+  EXPECT_EQ(eventTypes_[3], "custom event");
+  EXPECT_EQ(eventPriorities_[3], ReactEventPriority::Discrete);
+}
+
+TEST_F(EventQueueProcessorTest, alwaysContinuousEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {
+          RawEvent(
+              "onScroll",
+              dummyValueFactory_,
+              nullptr,
+              RawEvent::Category::Continuous),
+      });
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+
+  EXPECT_EQ(eventTypes_[0], "onScroll");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Default);
+}
+
+TEST_F(EventQueueProcessorTest, alwaysDiscreteEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {
+          RawEvent(
+              "onChange",
+              dummyValueFactory_,
+              nullptr,
+              RawEvent::Category::Discrete),
+      });
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+
+  EXPECT_EQ(eventTypes_[0], "onChange");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+}
+
+} // namespace facebook::react