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

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

@@ -11,9 +11,11 @@
 #include <memory>
 
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/components/view/ViewPropsInterpolation.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/EventDispatcher.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/core/State.h>
@@ -78,10 +80,6 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   ShadowNode::Unshared cloneShadowNode(
       const ShadowNode &sourceShadowNode,
       const ShadowNodeFragment &fragment) const override {
-    react_native_assert(
-        dynamic_cast<ConcreteShadowNode const *>(&sourceShadowNode) &&
-        "Provided `sourceShadowNode` has an incompatible type.");
-
     auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
 
     adopt(shadowNode);
@@ -91,10 +89,6 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   void appendChild(
       const ShadowNode::Shared &parentShadowNode,
       const ShadowNode::Shared &childShadowNode) const override {
-    react_native_assert(
-        dynamic_cast<ConcreteShadowNode const *>(parentShadowNode.get()) &&
-        "Provided `parentShadowNode` has an incompatible type.");
-
     auto concreteParentShadowNode =
         std::static_pointer_cast<const ShadowNodeT>(parentShadowNode);
     auto concreteNonConstParentShadowNode =
@@ -103,13 +97,9 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   }
 
   virtual SharedProps cloneProps(
+      const PropsParserContext &context,
       const SharedProps &props,
       const RawProps &rawProps) const override {
-    react_native_assert(
-        !props ||
-        dynamic_cast<ConcreteProps const *>(props.get()) &&
-            "Provided `props` has an incompatible type.");
-
     // Optimization:
     // Quite often nodes are constructed with default/empty props: the base
     // `props` object is `null` (there no base because it's not cloning) and the
@@ -119,25 +109,33 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
       return ShadowNodeT::defaultSharedProps();
     }
 
-    rawProps.parse(rawPropsParser_);
+    rawProps.parse(rawPropsParser_, context);
 
-    return ShadowNodeT::Props(rawProps, props);
+    return ShadowNodeT::Props(context, rawProps, props);
   };
 
-  virtual SharedProps interpolateProps(
+  SharedProps interpolateProps(
+      const PropsParserContext &context,
       float animationProgress,
       const SharedProps &props,
       const SharedProps &newProps) const override {
-    // By default, this does nothing.
 #ifdef ANDROID
     // On Android only, the merged props should have the same RawProps as the
     // final props struct
-    if (newProps != nullptr) {
-      return cloneProps(newProps, newProps->rawProps);
-    }
+    SharedProps interpolatedPropsShared =
+        (newProps != nullptr ? cloneProps(context, newProps, newProps->rawProps)
+                             : cloneProps(context, newProps, {}));
+#else
+    SharedProps interpolatedPropsShared = cloneProps(context, newProps, {});
 #endif
 
-    return cloneProps(newProps, {});
+    if (ConcreteShadowNode::BaseTraits().check(
+            ShadowNodeTraits::Trait::ViewKind)) {
+      interpolateViewProps(
+          animationProgress, props, newProps, interpolatedPropsShared);
+    }
+
+    return interpolatedPropsShared;
   };
 
   virtual State::Shared createInitialState(

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

@@ -10,6 +10,8 @@
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/core/ConcreteState.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/StateData.h>
 
@@ -68,9 +70,11 @@ class ConcreteShadowNode : public BaseShadowNodeT {
   }
 
   static SharedConcreteProps Props(
+      const PropsParserContext &context,
       RawProps const &rawProps,
       SharedProps const &baseProps = nullptr) {
     return std::make_shared<PropsT const>(
+        context,
         baseProps ? static_cast<PropsT const &>(*baseProps) : PropsT(),
         rawProps);
   }

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

@@ -17,26 +17,21 @@ namespace facebook {
 namespace react {
 
 EventDispatcher::EventDispatcher(
-    EventPipe const &eventPipe,
-    StatePipe const &statePipe,
+    EventQueueProcessor eventProcessor,
     EventBeat::Factory const &synchonousEventBeatFactory,
     EventBeat::Factory const &asynchonousEventBeatFactory,
     EventBeat::SharedOwnerBox const &ownerBox)
     : synchronousUnbatchedQueue_(std::make_unique<UnbatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           synchonousEventBeatFactory(ownerBox))),
       synchronousBatchedQueue_(std::make_unique<BatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           synchonousEventBeatFactory(ownerBox))),
       asynchronousUnbatchedQueue_(std::make_unique<UnbatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           asynchonousEventBeatFactory(ownerBox))),
       asynchronousBatchedQueue_(std::make_unique<BatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           asynchonousEventBeatFactory(ownerBox))) {}
 
 void EventDispatcher::dispatchEvent(RawEvent &&rawEvent, EventPriority priority)

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

@@ -7,21 +7,17 @@
 
 #pragma once
 
-#include <array>
-#include <memory>
-
 #include <react/renderer/core/BatchedEventQueue.h>
 #include <react/renderer/core/EventBeat.h>
-#include <react/renderer/core/EventPipe.h>
 #include <react/renderer/core/EventPriority.h>
-#include <react/renderer/core/StatePipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/StateUpdate.h>
 #include <react/renderer/core/UnbatchedEventQueue.h>
 
 namespace facebook {
 namespace react {
 
-class RawEvent;
+struct RawEvent;
 
 /*
  * Represents event-delivery infrastructure.
@@ -33,8 +29,7 @@ class EventDispatcher {
   using Weak = std::weak_ptr<EventDispatcher const>;
 
   EventDispatcher(
-      EventPipe const &eventPipe,
-      StatePipe const &statePipe,
+      EventQueueProcessor eventProcessor,
       EventBeat::Factory const &synchonousEventBeatFactory,
       EventBeat::Factory const &asynchonousEventBeatFactory,
       EventBeat::SharedOwnerBox const &ownerBox);

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

@@ -26,7 +26,7 @@ static std::string normalizeEventType(const std::string &type) {
   auto prefixedType = type;
   if (type.find("top", 0) != 0) {
     prefixedType.insert(0, "top");
-    prefixedType[3] = toupper(prefixedType[3]);
+    prefixedType[3] = static_cast<char>(toupper(prefixedType[3]));
   }
   return prefixedType;
 }
@@ -53,18 +53,24 @@ void EventEmitter::dispatchEvent(
     const std::string &type,
     const folly::dynamic &payload,
     EventPriority priority) const {
-  dispatchEvent(
-      type,
-      [payload](jsi::Runtime &runtime) {
-        return valueFromDynamic(runtime, payload);
-      },
-      priority);
+  dispatchEvent(type, [payload](jsi::Runtime &runtime) {
+    return valueFromDynamic(runtime, payload);
+  });
+}
+
+void EventEmitter::dispatchUniqueEvent(
+    const std::string &type,
+    const folly::dynamic &payload) const {
+  dispatchUniqueEvent(type, [payload](jsi::Runtime &runtime) {
+    return valueFromDynamic(runtime, payload);
+  });
 }
 
 void EventEmitter::dispatchEvent(
     const std::string &type,
     const ValueFactory &payloadFactory,
-    EventPriority priority) const {
+    EventPriority priority,
+    RawEvent::Category category) const {
   SystraceSection s("EventEmitter::dispatchEvent");
 
   auto eventDispatcher = eventDispatcher_.lock();
@@ -73,7 +79,8 @@ void EventEmitter::dispatchEvent(
   }
 
   eventDispatcher->dispatchEvent(
-      RawEvent(normalizeEventType(type), payloadFactory, eventTarget_),
+      RawEvent(
+          normalizeEventType(type), payloadFactory, eventTarget_, category),
       priority);
 }
 
@@ -87,8 +94,11 @@ void EventEmitter::dispatchUniqueEvent(
     return;
   }
 
-  eventDispatcher->dispatchUniqueEvent(
-      RawEvent(normalizeEventType(type), payloadFactory, eventTarget_));
+  eventDispatcher->dispatchUniqueEvent(RawEvent(
+      normalizeEventType(type),
+      payloadFactory,
+      eventTarget_,
+      RawEvent::Category::Continuous));
 }
 
 void EventEmitter::setEnabled(bool enabled) const {

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

@@ -71,13 +71,18 @@ class EventEmitter {
       const std::string &type,
       const ValueFactory &payloadFactory =
           EventEmitter::defaultPayloadFactory(),
-      EventPriority priority = EventPriority::AsynchronousBatched) const;
+      EventPriority priority = EventPriority::AsynchronousBatched,
+      RawEvent::Category category = RawEvent::Category::Unspecified) const;
 
   void dispatchEvent(
       const std::string &type,
       const folly::dynamic &payload,
       EventPriority priority = EventPriority::AsynchronousBatched) const;
 
+  void dispatchUniqueEvent(
+      const std::string &type,
+      const folly::dynamic &payload) const;
+
   void dispatchUniqueEvent(
       const std::string &type,
       const ValueFactory &payloadFactory =

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

@@ -12,6 +12,7 @@
 
 #include <jsi/jsi.h>
 #include <react/renderer/core/EventTarget.h>
+#include <react/renderer/core/ReactEventPriority.h>
 #include <react/renderer/core/ValueFactory.h>
 
 namespace facebook {
@@ -21,6 +22,7 @@ using EventPipe = std::function<void(
     jsi::Runtime &runtime,
     const EventTarget *eventTarget,
     const std::string &type,
+    ReactEventPriority priority,
     const ValueFactory &payloadFactory)>;
 
 } // namespace react

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

@@ -14,11 +14,9 @@ namespace facebook {
 namespace react {
 
 EventQueue::EventQueue(
-    EventPipe eventPipe,
-    StatePipe statePipe,
+    EventQueueProcessor eventProcessor,
     std::unique_ptr<EventBeat> eventBeat)
-    : eventPipe_(std::move(eventPipe)),
-      statePipe_(std::move(statePipe)),
+    : eventProcessor_(std::move(eventProcessor)),
       eventBeat_(std::move(eventBeat)) {
   eventBeat_->setBeatCallback(
       std::bind(&EventQueue::onBeat, this, std::placeholders::_1));
@@ -33,6 +31,36 @@ void EventQueue::enqueueEvent(RawEvent &&rawEvent) const {
   onEnqueue();
 }
 
+void EventQueue::enqueueUniqueEvent(RawEvent &&rawEvent) const {
+  {
+    std::lock_guard<std::mutex> lock(queueMutex_);
+
+    auto repeatedEvent = eventQueue_.rend();
+
+    for (auto it = eventQueue_.rbegin(); it != eventQueue_.rend(); ++it) {
+      if (it->type == rawEvent.type &&
+          it->eventTarget == rawEvent.eventTarget) {
+        repeatedEvent = it;
+        break;
+      } else if (it->eventTarget == rawEvent.eventTarget) {
+        // It is necessary to maintain order of different event types
+        // for the same target. If the same target has event types A1, B1
+        // in the event queue and event A2 occurs. A1 has to stay in the
+        // queue.
+        break;
+      }
+    }
+
+    if (repeatedEvent == eventQueue_.rend()) {
+      eventQueue_.push_back(std::move(rawEvent));
+    } else {
+      *repeatedEvent = std::move(rawEvent);
+    }
+  }
+
+  onEnqueue();
+}
+
 void EventQueue::enqueueStateUpdate(StateUpdate &&stateUpdate) const {
   {
     std::lock_guard<std::mutex> lock(queueMutex_);
@@ -49,8 +77,8 @@ void EventQueue::enqueueStateUpdate(StateUpdate &&stateUpdate) const {
 }
 
 void EventQueue::onBeat(jsi::Runtime &runtime) const {
-  flushEvents(runtime);
   flushStateUpdates();
+  flushEvents(runtime);
 }
 
 void EventQueue::flushEvents(jsi::Runtime &runtime) const {
@@ -67,30 +95,7 @@ void EventQueue::flushEvents(jsi::Runtime &runtime) const {
     eventQueue_.clear();
   }
 
-  {
-    std::lock_guard<std::mutex> lock(EventEmitter::DispatchMutex());
-
-    for (const auto &event : queue) {
-      if (event.eventTarget) {
-        event.eventTarget->retain(runtime);
-      }
-    }
-  }
-
-  for (const auto &event : queue) {
-    eventPipe_(
-        runtime, event.eventTarget.get(), event.type, event.payloadFactory);
-  }
-
-  // No need to lock `EventEmitter::DispatchMutex()` here.
-  // The mutex protects from a situation when the `instanceHandle` can be
-  // deallocated during accessing, but that's impossible at this point because
-  // we have a strong pointer to it.
-  for (const auto &event : queue) {
-    if (event.eventTarget) {
-      event.eventTarget->release(runtime);
-    }
-  }
+  eventProcessor_.flushEvents(runtime, std::move(queue));
 }
 
 void EventQueue::flushStateUpdates() const {
@@ -107,9 +112,7 @@ void EventQueue::flushStateUpdates() const {
     stateUpdateQueue_.clear();
   }
 
-  for (const auto &stateUpdate : stateUpdateQueue) {
-    statePipe_(stateUpdate);
-  }
+  eventProcessor_.flushStateUpdates(std::move(stateUpdateQueue));
 }
 
 } // namespace react

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

@@ -13,9 +13,8 @@
 
 #include <jsi/jsi.h>
 #include <react/renderer/core/EventBeat.h>
-#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/RawEvent.h>
-#include <react/renderer/core/StatePipe.h>
 #include <react/renderer/core/StateUpdate.h>
 
 namespace facebook {
@@ -28,8 +27,7 @@ namespace react {
 class EventQueue {
  public:
   EventQueue(
-      EventPipe eventPipe,
-      StatePipe statePipe,
+      EventQueueProcessor eventProcessor,
       std::unique_ptr<EventBeat> eventBeat);
   virtual ~EventQueue() = default;
 
@@ -39,6 +37,13 @@ class EventQueue {
    */
   void enqueueEvent(RawEvent &&rawEvent) const;
 
+  /*
+   * Enqueues and (probably later) dispatches a given event.
+   * Deletes last RawEvent from the queue if it has the same type and target.
+   * Can be called on any thread.
+   */
+  void enqueueUniqueEvent(RawEvent &&rawEvent) const;
+
   /*
    * Enqueues and (probably later) dispatch a given state update.
    * Can be called on any thread.
@@ -57,13 +62,14 @@ class EventQueue {
   void flushEvents(jsi::Runtime &runtime) const;
   void flushStateUpdates() const;
 
-  const EventPipe eventPipe_;
-  const StatePipe statePipe_;
+  EventQueueProcessor eventProcessor_;
+
   const std::unique_ptr<EventBeat> eventBeat_;
   // Thread-safe, protected by `queueMutex_`.
   mutable std::vector<RawEvent> eventQueue_;
   mutable std::vector<StateUpdate> stateUpdateQueue_;
   mutable std::mutex queueMutex_;
+  mutable bool hasContinuousEventStarted_{false};
 };
 
 } // namespace react

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

@@ -0,0 +1,82 @@
+/*
+ * 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 "EventQueue.h"
+
+#include "EventEmitter.h"
+#include "ShadowNodeFamily.h"
+
+namespace facebook {
+namespace react {
+
+EventQueueProcessor::EventQueueProcessor(
+    EventPipe eventPipe,
+    StatePipe statePipe)
+    : eventPipe_(std::move(eventPipe)), statePipe_(std::move(statePipe)) {}
+
+void EventQueueProcessor::flushEvents(
+    jsi::Runtime &runtime,
+    std::vector<RawEvent> &&events) const {
+  {
+    std::lock_guard<std::mutex> lock(EventEmitter::DispatchMutex());
+
+    for (const auto &event : events) {
+      if (event.eventTarget) {
+        event.eventTarget->retain(runtime);
+      }
+    }
+  }
+
+  for (auto const &event : events) {
+    if (event.category == RawEvent::Category::ContinuousEnd) {
+      hasContinuousEventStarted_ = false;
+    }
+
+    auto reactPriority = hasContinuousEventStarted_
+        ? ReactEventPriority::Default
+        : ReactEventPriority::Discrete;
+
+    if (event.category == RawEvent::Category::Continuous) {
+      reactPriority = ReactEventPriority::Default;
+    }
+
+    if (event.category == RawEvent::Category::Discrete) {
+      reactPriority = ReactEventPriority::Discrete;
+    }
+
+    eventPipe_(
+        runtime,
+        event.eventTarget.get(),
+        event.type,
+        reactPriority,
+        event.payloadFactory);
+
+    if (event.category == RawEvent::Category::ContinuousStart) {
+      hasContinuousEventStarted_ = true;
+    }
+  }
+
+  // No need to lock `EventEmitter::DispatchMutex()` here.
+  // The mutex protects from a situation when the `instanceHandle` can be
+  // deallocated during accessing, but that's impossible at this point because
+  // we have a strong pointer to it.
+  for (const auto &event : events) {
+    if (event.eventTarget) {
+      event.eventTarget->release(runtime);
+    }
+  }
+}
+
+void EventQueueProcessor::flushStateUpdates(
+    std::vector<StateUpdate> &&states) const {
+  for (const auto &stateUpdate : states) {
+    statePipe_(stateUpdate);
+  }
+}
+
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,36 @@
+/*
+ * 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
+
+#include <vector>
+
+#include <jsi/jsi.h>
+#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/RawEvent.h>
+#include <react/renderer/core/StatePipe.h>
+#include <react/renderer/core/StateUpdate.h>
+
+namespace facebook {
+namespace react {
+
+class EventQueueProcessor {
+ public:
+  EventQueueProcessor(EventPipe eventPipe, StatePipe statePipe);
+
+  void flushEvents(jsi::Runtime &runtime, std::vector<RawEvent> &&events) const;
+  void flushStateUpdates(std::vector<StateUpdate> &&states) const;
+
+ private:
+  EventPipe const eventPipe_;
+  StatePipe const statePipe_;
+
+  mutable bool hasContinuousEventStarted_{false};
+};
+
+} // namespace react
+} // namespace facebook

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

@@ -216,7 +216,7 @@ ShadowNode::Shared LayoutableShadowNode::findNodeAtPoint(
     ShadowNode::Shared node,
     Point point) {
   auto layoutableShadowNode =
-      dynamic_cast<const LayoutableShadowNode *>(node.get());
+      traitCast<const LayoutableShadowNode *>(node.get());
 
   if (!layoutableShadowNode) {
     return nullptr;

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

@@ -170,9 +170,6 @@ inline LayoutableShadowNode const &traitCast<LayoutableShadowNode const &>(
     ShadowNode const &shadowNode) {
   bool castable =
       shadowNode.getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  react_native_assert(
-      castable ==
-      (dynamic_cast<LayoutableShadowNode const *>(&shadowNode) != nullptr));
   react_native_assert(castable);
   (void)castable;
   return static_cast<LayoutableShadowNode const &>(shadowNode);
@@ -186,9 +183,6 @@ inline LayoutableShadowNode const *traitCast<LayoutableShadowNode const *>(
   }
   bool castable =
       shadowNode->getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  react_native_assert(
-      castable ==
-      (dynamic_cast<LayoutableShadowNode const *>(shadowNode) != nullptr));
   if (!castable) {
     return nullptr;
   }

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

@@ -13,8 +13,16 @@
 namespace facebook {
 namespace react {
 
-Props::Props(const Props &sourceProps, const RawProps &rawProps)
-    : nativeId(convertRawProp(rawProps, "nativeID", sourceProps.nativeId, {})),
+Props::Props(
+    const PropsParserContext &context,
+    const Props &sourceProps,
+    const RawProps &rawProps)
+    : nativeId(convertRawProp(
+          context,
+          rawProps,
+          "nativeID",
+          sourceProps.nativeId,
+          {})),
       revision(sourceProps.revision + 1)
 #ifdef ANDROID
       ,

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

@@ -9,6 +9,8 @@
 
 #include <folly/dynamic.h>
 
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/Sealable.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
@@ -28,7 +30,10 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
   using Shared = std::shared_ptr<Props const>;
 
   Props() = default;
-  Props(Props const &sourceProps, RawProps const &rawProps);
+  Props(
+      const PropsParserContext &context,
+      const Props &sourceProps,
+      RawProps const &rawProps);
   virtual ~Props() = default;
 
   std::string nativeId;

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

@@ -0,0 +1,29 @@
+/*
+ * 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
+
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook {
+namespace react {
+
+// For props requiring some context to parse, this toolbox can be used.
+// It should be used as infrequently as possible - most props can and should
+// be parsed without any context.
+struct PropsParserContext {
+  // Non-copyable
+  PropsParserContext(const PropsParserContext &) = delete;
+  PropsParserContext &operator=(const PropsParserContext &) = delete;
+
+  SurfaceId const surfaceId;
+  ContextContainer const &contextContainer;
+};
+
+} // namespace react
+} // namespace facebook

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

@@ -13,10 +13,12 @@ namespace react {
 RawEvent::RawEvent(
     std::string type,
     ValueFactory payloadFactory,
-    SharedEventTarget eventTarget)
+    SharedEventTarget eventTarget,
+    Category category)
     : type(std::move(type)),
       payloadFactory(std::move(payloadFactory)),
-      eventTarget(std::move(eventTarget)) {}
+      eventTarget(std::move(eventTarget)),
+      category(category) {}
 
 } // namespace react
 } // namespace facebook