react-native-tvos 0.64.2-2 → 0.66.3-0

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

@@ -9,6 +9,7 @@
 
 #include <react/renderer/core/EventDispatcher.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawPropsParser.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/State.h>
@@ -40,8 +41,8 @@ class ComponentDescriptor {
    * and `ComponentHandle` (the particular custom implementation might use
    * stored `flavor` to return different values from those virtual methods).
    * Since it's a very niche requirement (e.g. we plan to use it for
-   * an interoperability layer with Paper), we are thinking about removing this
-   * feature completely after it's no longer needed.
+   * an interoperability layer with old renderer), we are thinking about
+   * removing this feature completely after it's no longer needed.
    */
   using Flavor = std::shared_ptr<void const>;
 
@@ -82,7 +83,7 @@ class ComponentDescriptor {
   /*
    * Clones a `ShadowNode` with optionally new `props` and/or `children`.
    */
-  virtual UnsharedShadowNode cloneShadowNode(
+  virtual ShadowNode::Unshared cloneShadowNode(
       const ShadowNode &sourceShadowNode,
       const ShadowNodeFragment &fragment) const = 0;
 
@@ -101,6 +102,7 @@ class ComponentDescriptor {
    * Must return an object which is NOT pointer equal to `props`.
    */
   virtual SharedProps cloneProps(
+      const PropsParserContext &context,
       const SharedProps &props,
       const RawProps &rawProps) const = 0;
 
@@ -109,6 +111,7 @@ class ComponentDescriptor {
    * between `props` and `newProps`.
    */
   virtual SharedProps interpolateProps(
+      const PropsParserContext &context,
       float animationProgress,
       const SharedProps &props,
       const SharedProps &newProps) const = 0;

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

@@ -10,9 +10,11 @@
 #include <functional>
 #include <memory>
 
+#include <react/debug/react_native_assert.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>
@@ -63,7 +65,8 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   ShadowNode::Shared createShadowNode(
       const ShadowNodeFragment &fragment,
       ShadowNodeFamily::Shared const &family) const override {
-    assert(std::dynamic_pointer_cast<const ConcreteProps>(fragment.props));
+    react_native_assert(
+        std::dynamic_pointer_cast<const ConcreteProps>(fragment.props));
 
     auto shadowNode =
         std::make_shared<ShadowNodeT>(fragment, family, getTraits());
@@ -73,13 +76,9 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
     return shadowNode;
   }
 
-  UnsharedShadowNode cloneShadowNode(
+  ShadowNode::Unshared cloneShadowNode(
       const ShadowNode &sourceShadowNode,
       const ShadowNodeFragment &fragment) const override {
-    assert(
-        dynamic_cast<ConcreteShadowNode const *>(&sourceShadowNode) &&
-        "Provided `sourceShadowNode` has an incompatible type.");
-
     auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
 
     adopt(shadowNode);
@@ -89,10 +88,6 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   void appendChild(
       const ShadowNode::Shared &parentShadowNode,
       const ShadowNode::Shared &childShadowNode) const override {
-    assert(
-        dynamic_cast<ConcreteShadowNode const *>(parentShadowNode.get()) &&
-        "Provided `parentShadowNode` has an incompatible type.");
-
     auto concreteParentShadowNode =
         std::static_pointer_cast<const ShadowNodeT>(parentShadowNode);
     auto concreteNonConstParentShadowNode =
@@ -101,13 +96,9 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   }
 
   virtual SharedProps cloneProps(
+      const PropsParserContext &context,
       const SharedProps &props,
       const RawProps &rawProps) const override {
-    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
@@ -117,17 +108,26 @@ 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(
+      const PropsParserContext &context,
       float animationProgress,
       const SharedProps &props,
       const SharedProps &newProps) const override {
     // By default, this does nothing.
-    return cloneProps(newProps, {});
+#ifdef ANDROID
+    // On Android only, the merged props should have the same RawProps as the
+    // final props struct
+    if (newProps != nullptr) {
+      return cloneProps(context, newProps, newProps->rawProps);
+    }
+#endif
+
+    return cloneProps(context, newProps, {});
   };
 
   virtual State::Shared createInitialState(
@@ -153,14 +153,14 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
       return nullptr;
     }
 
-    assert(data && "Provided `data` is nullptr.");
+    react_native_assert(data && "Provided `data` is nullptr.");
 
     return std::make_shared<ConcreteState const>(
         std::static_pointer_cast<ConcreteStateData const>(data),
         *family.getMostRecentState());
   }
 
-  virtual ShadowNodeFamily::Shared createFamily(
+  ShadowNodeFamily::Shared createFamily(
       ShadowNodeFamilyFragment const &fragment,
       SharedEventTarget eventTarget) const override {
     auto eventEmitter = std::make_shared<ConcreteEventEmitter const>(
@@ -173,9 +173,10 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   }
 
  protected:
-  virtual void adopt(UnsharedShadowNode shadowNode) const {
+  virtual void adopt(ShadowNode::Unshared const &shadowNode) const {
     // Default implementation does nothing.
-    assert(shadowNode->getComponentHandle() == getComponentHandle());
+    react_native_assert(
+        shadowNode->getComponentHandle() == getComponentHandle());
   }
 };
 

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

@@ -7,9 +7,10 @@
 
 #pragma once
 
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/ConcreteState.h>
-#include <react/renderer/core/ConcreteStateTeller.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/StateData.h>
 
@@ -49,7 +50,6 @@ class ConcreteShadowNode : public BaseShadowNodeT {
   using SharedConcreteEventEmitter = std::shared_ptr<EventEmitterT const>;
   using SharedConcreteShadowNode = std::shared_ptr<ConcreteShadowNode const>;
   using ConcreteState = ConcreteState<StateDataT>;
-  using ConcreteStateTeller = ConcreteStateTeller<ConcreteState>;
   using ConcreteStateData = StateDataT;
 
   static ComponentName Name() {
@@ -69,9 +69,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);
   }
@@ -94,8 +96,9 @@ class ConcreteShadowNode : public BaseShadowNodeT {
    * Thread-safe after the node is sealed.
    */
   ConcreteProps const &getConcreteProps() const {
-    assert(BaseShadowNodeT::props_ && "Props must not be `nullptr`.");
-    assert(
+    react_native_assert(
+        BaseShadowNodeT::props_ && "Props must not be `nullptr`.");
+    react_native_assert(
         std::dynamic_pointer_cast<ConcreteProps const>(props_) &&
         "Props must be an instance of ConcreteProps class.");
     return static_cast<ConcreteProps const &>(*props_);
@@ -106,7 +109,7 @@ class ConcreteShadowNode : public BaseShadowNodeT {
    * Thread-safe after the node is sealed.
    */
   ConcreteEventEmitter const &getConcreteEventEmitter() const {
-    assert(
+    react_native_assert(
         std::dynamic_pointer_cast<ConcreteEventEmitter const>(
             BaseShadowNodeT::getEventEmitter()) &&
         "EventEmitter must be an instance of ConcreteEventEmitter class.");
@@ -119,8 +122,8 @@ class ConcreteShadowNode : public BaseShadowNodeT {
    * Thread-safe after the node is sealed.
    */
   ConcreteStateData const &getStateData() const {
-    assert(state_ && "State must not be `nullptr`.");
-    assert(
+    react_native_assert(state_ && "State must not be `nullptr`.");
+    react_native_assert(
         std::dynamic_pointer_cast<ConcreteState const>(state_) &&
         "State must be an instance of ConcreteState class.");
     return static_cast<ConcreteState const *>(state_.get())->getData();

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

@@ -10,6 +10,7 @@
 #include <functional>
 #include <memory>
 
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/State.h>
 
 namespace facebook {
@@ -60,55 +61,23 @@ class ConcreteState : public State {
    */
   void updateState(
       Data &&newData,
-      std::function<void()> failureCallback = nullptr,
       EventPriority priority = EventPriority::AsynchronousUnbatched) const {
     updateState(
-        [data = std::move(newData)](Data const &oldData) mutable -> Data && {
-          return std::move(data);
+        [data{std::move(newData)}](Data const &oldData) -> SharedData {
+          return std::make_shared<Data const>(data);
         },
-        failureCallback,
         priority);
   }
 
   /*
    * Initiate a state update process with a given function (that transforms an
-   * old data value to a new one) and priority. The update function can be
-   * called from any thread any moment later. The function can be called only
-   * once or not called at all (in the case where the node was already unmounted
-   * and updating makes no sense). The state update operation might fail in case
-   * of conflict.
+   * old data value to a new one) and priority. The callback function can be
+   * called from any thread any moment later.
+   * In case of a conflict, the `callback` might be called several times until
+   * it succeeded. To cancel the state update operation, the callback needs to
+   * return `nullptr`.
    */
   void updateState(
-      std::function<Data(Data const &oldData)> callback,
-      std::function<void()> failureCallback = nullptr,
-      EventPriority priority = EventPriority::AsynchronousBatched) const {
-    auto family = family_.lock();
-
-    if (!family) {
-      // No more nodes of this family exist anymore,
-      // updating state is impossible.
-      return;
-    }
-
-    auto stateUpdate = StateUpdate{
-        family,
-        [=](StateData::Shared const &oldData) -> StateData::Shared {
-          assert(oldData);
-          return std::make_shared<Data const>(
-              callback(*std::static_pointer_cast<Data const>(oldData)));
-        },
-        failureCallback,
-        false};
-
-    family->dispatchRawState(std::move(stateUpdate), priority);
-  }
-
-  /*
-   * An experimental version of `updateState` function that re-commit the state
-   * update over and over again until it succeeded. To cancel the state update
-   * operation, the state update lambda needs to return `nullptr`.
-   */
-  void updateStateWithAutorepeat(
       std::function<StateData::Shared(Data const &oldData)> callback,
       EventPriority priority = EventPriority::AsynchronousBatched) const {
     auto family = family_.lock();
@@ -120,14 +89,10 @@ class ConcreteState : public State {
     }
 
     auto stateUpdate = StateUpdate{
-        family,
-        [=](StateData::Shared const &oldData) -> StateData::Shared {
-          assert(oldData);
+        family, [=](StateData::Shared const &oldData) -> StateData::Shared {
+          react_native_assert(oldData);
           return callback(*std::static_pointer_cast<Data const>(oldData));
-        },
-        nullptr,
-        true,
-    };
+        }};
 
     family->dispatchRawState(std::move(stateUpdate), priority);
   }
@@ -137,9 +102,11 @@ class ConcreteState : public State {
     return getData().getDynamic();
   }
 
-  void updateState(folly::dynamic data, std::function<void()> failureCallback)
-      const override {
-    updateState(std::move(Data(getData(), data)), failureCallback);
+  void updateState(folly::dynamic data) const override {
+    updateState(std::move(Data(getData(), data)));
+  }
+  MapBuffer getMapBuffer() const override {
+    return getData().getMapBuffer();
   }
 #endif
 };

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

@@ -0,0 +1,24 @@
+/*
+ * 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 "Constants.h"
+
+namespace facebook {
+namespace react {
+
+static bool isPropsForwardingEnabled = false;
+
+void Constants::setPropsForwardingEnabled(bool propsForwardingEnabled) {
+  isPropsForwardingEnabled = propsForwardingEnabled;
+}
+
+bool Constants::getPropsForwardingEnabled() {
+  return isPropsForwardingEnabled;
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/{components/picker/androidpicker/react/renderer/components/androidpicker/AndroidDialogPickerComponentDescriptor.h → core/Constants.h}

@@ -7,15 +7,17 @@
 
 #pragma once
 
-#include "AndroidDialogPickerShadowNode.h"
-
-#include <react/renderer/core/ConcreteComponentDescriptor.h>
-
 namespace facebook {
 namespace react {
 
-using AndroidDialogPickerComponentDescriptor =
-    ConcreteComponentDescriptor<AndroidDialogPickerShadowNode>;
+struct Constants {
+  /*
+      Flag controlling props forwarding when shadow node is cloned on Android.
+      Has no effect on iOS.
+  */
+  static void setPropsForwardingEnabled(bool propsForwardingEnabled);
+  static bool getPropsForwardingEnabled();
+};
 
 } // namespace react
 } // namespace facebook

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

@@ -0,0 +1,35 @@
+/*
+ * 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 "DynamicPropsUtilities.h"
+
+namespace facebook {
+namespace react {
+folly::dynamic mergeDynamicProps(
+    folly::dynamic const &source,
+    folly::dynamic const &patch) {
+  auto result = source;
+
+  if (!result.isObject()) {
+    result = folly::dynamic::object();
+  }
+
+  if (!patch.isObject()) {
+    return result;
+  }
+
+  // Note, here we have to preserve sub-prop objects with `null` value as
+  // an indication for the legacy mounting layer that it needs to clean them up.
+  for (auto const &pair : patch.items()) {
+    result[pair.first] = pair.second;
+  }
+
+  return result;
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/{components/picker/iospicker/PickerState.h → core/DynamicPropsUtilities.h}

@@ -7,13 +7,14 @@
 
 #pragma once
 
+#include <folly/dynamic.h>
+
 namespace facebook {
 namespace react {
 
-/*
- * State for <Picker> component.
- */
-class PickerState final {};
+folly::dynamic mergeDynamicProps(
+    folly::dynamic const &source,
+    folly::dynamic const &patch);
 
 } // namespace react
 } // namespace facebook

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

@@ -17,31 +17,25 @@ 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 const &rawEvent,
-    EventPriority priority) const {
+void EventDispatcher::dispatchEvent(RawEvent &&rawEvent, EventPriority priority)
+    const {
   getEventQueue(priority).enqueueEvent(std::move(rawEvent));
 }
 
@@ -51,8 +45,8 @@ void EventDispatcher::dispatchStateUpdate(
   getEventQueue(priority).enqueueStateUpdate(std::move(stateUpdate));
 }
 
-void EventDispatcher::dispatchUniqueEvent(RawEvent const &rawEvent) const {
-  asynchronousBatchedQueue_->enqueueUniqueEvent(rawEvent);
+void EventDispatcher::dispatchUniqueEvent(RawEvent &&rawEvent) const {
+  asynchronousBatchedQueue_->enqueueUniqueEvent(std::move(rawEvent));
 }
 
 const EventQueue &EventDispatcher::getEventQueue(EventPriority priority) const {

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);
@@ -42,14 +37,14 @@ class EventDispatcher {
   /*
    * Dispatches a raw event with given priority using event-delivery pipe.
    */
-  void dispatchEvent(RawEvent const &rawEvent, EventPriority priority) const;
+  void dispatchEvent(RawEvent &&rawEvent, EventPriority priority) const;
 
   /*
    * Dispatches a raw event with asynchronous batched priority. Before the
    * dispatch we make sure that no other RawEvent of same type and same target
    * is on the queue.
    */
-  void dispatchUniqueEvent(RawEvent const &rawEvent) const;
+  void dispatchUniqueEvent(RawEvent &&rawEvent) const;
 
   /*
    * Dispatches a state update with given priority.

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;
 }
@@ -52,19 +52,25 @@ EventEmitter::EventEmitter(
 void EventEmitter::dispatchEvent(
     const std::string &type,
     const folly::dynamic &payload,
-    const EventPriority &priority) const {
-  dispatchEvent(
-      type,
-      [payload](jsi::Runtime &runtime) {
-        return valueFromDynamic(runtime, payload);
-      },
-      priority);
+    EventPriority priority) const {
+  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,
-    const 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,12 +71,17 @@ class EventEmitter {
       const std::string &type,
       const ValueFactory &payloadFactory =
           EventEmitter::defaultPayloadFactory(),
-      const 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,
-      const EventPriority &priority = EventPriority::AsynchronousBatched) const;
+      EventPriority priority = EventPriority::AsynchronousBatched) const;
+
+  void dispatchUniqueEvent(
+      const std::string &type,
+      const folly::dynamic &payload) const;
 
   void dispatchUniqueEvent(
       const std::string &type,

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/EventPriority.h

@@ -10,7 +10,7 @@
 namespace facebook {
 namespace react {
 
-enum class EventPriority : int {
+enum class EventPriority {
   SynchronousUnbatched,
   SynchronousBatched,
   AsynchronousUnbatched,