react-native-tvos 0.75.2-0rc0 → 0.76.0-0rc0

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

@@ -33,6 +33,8 @@ class EventEmitter {
  public:
   using Shared = std::shared_ptr<const EventEmitter>;
 
+  static std::string normalizeEventType(std::string type);
+
   static std::mutex& DispatchMutex();
 
   static ValueFactory defaultPayloadFactory();

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

@@ -16,16 +16,19 @@ bool EventListenerContainer::willDispatchEvent(const RawEvent& event) {
 
   bool handled = false;
   for (const auto& listener : eventListeners_) {
-    handled = handled || listener->operator()(event);
+    handled = (*listener)(event);
+    if (handled) {
+      break;
+    }
   }
   return handled;
 }
 
 void EventListenerContainer::addListener(
-    const std::shared_ptr<const EventListener>& listener) {
+    std::shared_ptr<const EventListener> listener) {
   std::unique_lock lock(mutex_);
 
-  eventListeners_.push_back(listener);
+  eventListeners_.push_back(std::move(listener));
 }
 
 void EventListenerContainer::removeListener(

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

@@ -30,7 +30,7 @@ class EventListenerContainer {
    */
   bool willDispatchEvent(const RawEvent& event);
 
-  void addListener(const std::shared_ptr<const EventListener>& listener);
+  void addListener(std::shared_ptr<const EventListener> listener);
   void removeListener(const std::shared_ptr<const EventListener>& listener);
 
  private:

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

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <react/renderer/core/EventTarget.h>
 #include <string_view>
 
 namespace facebook::react {
@@ -27,7 +28,9 @@ class EventLogger {
    * Called when an event is first created, returns and unique tag for this
    * event, which can be used to log further event processing stages.
    */
-  virtual EventTag onEventStart(std::string_view name) = 0;
+  virtual EventTag onEventStart(
+      std::string_view name,
+      SharedEventTarget target) = 0;
 
   /*
    * Called when event starts getting dispatched (processed by the handlers, if

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

@@ -9,6 +9,6 @@
 
 namespace facebook::react {
 
-enum class EventPayloadType { ValueFactory, PointerEvent };
+enum class EventPayloadType { ValueFactory, PointerEvent, ScrollEvent };
 
 }

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

@@ -7,6 +7,7 @@
 
 #include <cxxreact/JSExecutor.h>
 #include <logger/react_native_log.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include "EventEmitter.h"
 #include "EventLogger.h"
 #include "EventQueue.h"
@@ -38,20 +39,43 @@ void EventQueueProcessor::flushEvents(
   }
 
   for (const auto& event : events) {
-    if (event.category == RawEvent::Category::ContinuousEnd) {
-      hasContinuousEventStarted_ = false;
-    }
+    auto reactPriority = ReactEventPriority::Default;
+
+    if (ReactNativeFeatureFlags::
+            fixMappingOfEventPrioritiesBetweenFabricAndReact()) {
+      reactPriority = [&]() {
+        switch (event.category) {
+          case RawEvent::Category::Discrete:
+            return ReactEventPriority::Discrete;
+          case RawEvent::Category::ContinuousStart:
+            hasContinuousEventStarted_ = true;
+            return ReactEventPriority::Discrete;
+          case RawEvent::Category::ContinuousEnd:
+            hasContinuousEventStarted_ = false;
+            return ReactEventPriority::Discrete;
+          case RawEvent::Category::Continuous:
+            return ReactEventPriority::Continuous;
+          case RawEvent::Category::Unspecified:
+            return hasContinuousEventStarted_ ? ReactEventPriority::Continuous
+                                              : ReactEventPriority::Default;
+        }
+        return ReactEventPriority::Default;
+      }();
+    } else {
+      if (event.category == RawEvent::Category::ContinuousEnd) {
+        hasContinuousEventStarted_ = false;
+      }
 
-    auto reactPriority = hasContinuousEventStarted_
-        ? ReactEventPriority::Default
-        : ReactEventPriority::Discrete;
+      reactPriority = hasContinuousEventStarted_ ? ReactEventPriority::Default
+                                                 : ReactEventPriority::Discrete;
 
-    if (event.category == RawEvent::Category::Continuous) {
-      reactPriority = ReactEventPriority::Default;
-    }
+      if (event.category == RawEvent::Category::Continuous) {
+        reactPriority = ReactEventPriority::Default;
+      }
 
-    if (event.category == RawEvent::Category::Discrete) {
-      reactPriority = ReactEventPriority::Discrete;
+      if (event.category == RawEvent::Category::Discrete) {
+        reactPriority = ReactEventPriority::Discrete;
+      }
     }
 
     auto eventLogger = eventLogger_.lock();

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

@@ -13,8 +13,11 @@ namespace facebook::react {
 
 using Tag = EventTarget::Tag;
 
-EventTarget::EventTarget(InstanceHandle::Shared instanceHandle)
+EventTarget::EventTarget(
+    InstanceHandle::Shared instanceHandle,
+    SurfaceId surfaceId)
     : instanceHandle_(std::move(instanceHandle)),
+      surfaceId_(surfaceId),
       strongInstanceHandle_(jsi::Value::null()) {}
 
 void EventTarget::setEnabled(bool enabled) const {
@@ -64,6 +67,10 @@ jsi::Value EventTarget::getInstanceHandle(jsi::Runtime& runtime) const {
   return jsi::Value(runtime, strongInstanceHandle_);
 }
 
+SurfaceId EventTarget::getSurfaceId() const {
+  return surfaceId_;
+}
+
 Tag EventTarget::getTag() const {
   return instanceHandle_->getTag();
 }

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

@@ -34,7 +34,9 @@ class EventTarget {
   /*
    * Constructs an EventTarget from a weak instance handler and a tag.
    */
-  explicit EventTarget(InstanceHandle::Shared instanceHandle);
+  explicit EventTarget(
+      InstanceHandle::Shared instanceHandle,
+      SurfaceId surfaceId);
 
   /*
    * Sets the `enabled` flag that allows creating a strong instance handle from
@@ -59,6 +61,8 @@ class EventTarget {
    */
   jsi::Value getInstanceHandle(jsi::Runtime& runtime) const;
 
+  SurfaceId getSurfaceId() const;
+
   /*
    * Deprecated. Do not use.
    */
@@ -66,6 +70,7 @@ class EventTarget {
 
  private:
   const InstanceHandle::Shared instanceHandle_;
+  const SurfaceId surfaceId_;
   mutable bool enabled_{false}; // Protected by `EventEmitter::DispatchMutex()`.
   mutable jsi::Value strongInstanceHandle_; // Protected by `jsi::Runtime &`.
   mutable size_t retainCount_{0}; // Protected by `jsi::Runtime &`.

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

@@ -240,11 +240,9 @@ Size LayoutableShadowNode::measure(
   return layoutableShadowNode.getLayoutMetrics().frame.size;
 }
 
-Float LayoutableShadowNode::firstBaseline(Size /*size*/) const {
-  return 0;
-}
-
-Float LayoutableShadowNode::lastBaseline(Size /*size*/) const {
+Float LayoutableShadowNode::baseline(
+    const LayoutContext& /*layoutContext*/,
+    Size /*size*/) const {
   return 0;
 }
 
@@ -263,8 +261,9 @@ ShadowNode::Shared LayoutableShadowNode::findNodeAtPoint(
     return nullptr;
   }
 
+  auto transform = layoutableShadowNode->getTransform();
   auto frame = layoutableShadowNode->getLayoutMetrics().frame;
-  auto transformedFrame = frame * layoutableShadowNode->getTransform();
+  auto transformedFrame = frame * transform;
   auto isPointInside = transformedFrame.containsPoint(point);
 
   if (!isPointInside) {
@@ -273,6 +272,27 @@ ShadowNode::Shared LayoutableShadowNode::findNodeAtPoint(
     return node;
   }
 
+  if (Transform::isVerticalInversion(transform) ||
+      Transform::isHorizontalInversion(transform)) {
+    auto centerX =
+        transformedFrame.origin.x + transformedFrame.size.width / 2.0;
+    auto centerY =
+        transformedFrame.origin.y + transformedFrame.size.height / 2.0;
+
+    auto relativeX = float(point.x - centerX);
+    auto relativeY = float(point.y - centerY);
+
+    if (Transform::isVerticalInversion(transform)) {
+      relativeY = -relativeY;
+    }
+    if (Transform::isHorizontalInversion(transform)) {
+      relativeX = -relativeX;
+    }
+
+    point.x = centerX + relativeX;
+    point.y = centerY + relativeY;
+  }
+
   auto newPoint = point - transformedFrame.origin -
       layoutableShadowNode->getContentOriginOffset(false);
 

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

@@ -122,7 +122,7 @@ class LayoutableShadowNode : public ShadowNode {
    * Returns offset which is applied to children's origin in
    * `LayoutableShadowNode::getRelativeLayoutMetrics` and
    * `LayoutableShadowNode::findNodeAtPoint`.
-   * i`ncludeTransform` is a flag to include the transform in the offset. This
+   * `includeTransform` is a flag to include the transform in the offset. This
    * is a rare case but needed for case where transform is involved for e.g. in
    * ScrollView.
    */
@@ -153,8 +153,7 @@ class LayoutableShadowNode : public ShadowNode {
   /*
    * Unifed methods to access text layout metrics.
    */
-  virtual Float firstBaseline(Size size) const;
-  virtual Float lastBaseline(Size size) const;
+  virtual Float baseline(const LayoutContext& layoutContext, Size size) const;
 
   virtual bool canBeTouchTarget() const;
   virtual bool canChildrenBeTouchTarget() const;

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

@@ -59,6 +59,11 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
 
 #ifdef ANDROID
   folly::dynamic rawProps = folly::dynamic::object();
+
+  virtual folly::dynamic getDiffProps(const Props* prevProps) const {
+    return folly::dynamic::object();
+  }
+
 #endif
 
  protected:

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

@@ -110,15 +110,19 @@
       struct, blockStart, prefix "BlockStart" suffix, rawValue)
 
 // Rebuild a type that contains multiple fields from a single field value
-#define REBUILD_FIELD_SWITCH_CASE(                  \
-    defaults, rawValue, property, field, fieldName) \
-  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {   \
-    if ((rawValue).hasValue()) {                    \
-      decltype((defaults).field) res;               \
-      fromRawValue(context, rawValue, res);         \
-      (property).field = res;                       \
-    } else {                                        \
-      (property).field = (defaults).field;          \
-    }                                               \
-    return;                                         \
+#define REBUILD_FIELD_SWITCH_CASE(                                 \
+    defaults, rawValue, property, field, fieldName)                \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                  \
+    if ((rawValue).hasValue()) [[likely]] {                        \
+      try {                                                        \
+        fromRawValue(context, rawValue, (property).field);         \
+      } catch (const std::exception& e) {                          \
+        LOG(ERROR) << "Error while converting prop '" << fieldName \
+                   << "': " << e.what();                           \
+        (property).field = (defaults).field;                       \
+      }                                                            \
+    } else {                                                       \
+      (property).field = (defaults).field;                         \
+    }                                                              \
+    return;                                                        \
   }

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

@@ -7,6 +7,7 @@
 
 #include "RawProps.h"
 
+#include <cxxreact/SystraceSection.h>
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsParser.h>
@@ -209,10 +210,4 @@ const RawValue* RawProps::at(
   return parser_->at(*this, RawPropsKey{prefix, name, suffix});
 }
 
-void RawProps::iterateOverValues(
-    const std::function<
-        void(RawPropsPropNameHash, const char*, const RawValue&)>& fn) const {
-  return parser_->iterateOverValues(*this, fn);
-}
-
 } // namespace facebook::react

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

@@ -95,14 +95,6 @@ class RawProps final {
   const RawValue* at(const char* name, const char* prefix, const char* suffix)
       const noexcept;
 
-  /**
-   * Iterator functions: for when you want to iterate over values in-order
-   * instead of using `at` to access values randomly.
-   */
-  void iterateOverValues(
-      const std::function<
-          void(RawPropsPropNameHash, const char*, const RawValue&)>& fn) const;
-
  private:
   friend class RawPropsParser;
 

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

@@ -62,7 +62,7 @@ void RawPropsKeyMap::reindex() noexcept {
     auto result = it;
     while (++it != end) {
       if (hasSameName(*result, *it)) {
-        LOG(ERROR)
+        LOG(WARNING)
             << "Component property map contains multiple entries for '"
             << std::string_view(it->name, it->length)
             << "'. Ensure all calls to convertRawProp use a consistent prefix, name and suffix.";

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

@@ -45,23 +45,23 @@ const RawValue* RawPropsParser::at(
     return nullptr;
   }
 
-  // Normally, keys are looked up in-order. For performance we can simply
-  // increment this key counter, and if the key is equal to the key at the next
-  // index, there's no need to do any lookups. However, it's possible for keys
-  // to be accessed out-of-order or multiple times, in which case we start
-  // searching again from index 0.
-  // To prevent infinite loops (which can occur if you look up a key that
-  // doesn't exist) we keep track of whether or not we've already looped around,
-  // and log and return nullptr if so. However, we ONLY do this in debug mode,
-  // where you're more likely to look up a nonexistent key as part of debugging.
-  // You can (and must) ensure infinite loops are not possible in production by:
-  // (1) constructing all props objects without conditionals, or (2) if there
-  // are conditionals, ensure that in the parsing setup case, the Props
-  // constructor will access _all_ possible props. To ensure this performance
-  // optimization is utilized, always access props in the same order every time.
-  // This is trivial if you have a simple Props constructor, but difficult or
-  // impossible if you have a shared sub-prop Struct that is used by multiple
-  // parent Props.
+// Normally, keys are looked up in-order. For performance we can simply
+// increment this key counter, and if the key is equal to the key at the next
+// index, there's no need to do any lookups. However, it's possible for keys
+// to be accessed out-of-order or multiple times, in which case we start
+// searching again from index 0.
+// To prevent infinite loops (which can occur if you look up a key that
+// doesn't exist) we keep track of whether or not we've already looped around,
+// and log and return nullptr if so. However, we ONLY do this in debug mode,
+// where you're more likely to look up a nonexistent key as part of debugging.
+// You can (and must) ensure infinite loops are not possible in production by:
+// (1) constructing all props objects without conditionals, or (2) if there
+// are conditionals, ensure that in the parsing setup case, the Props
+// constructor will access _all_ possible props. To ensure this performance
+// optimization is utilized, always access props in the same order every time.
+// This is trivial if you have a simple Props constructor, but difficult or
+// impossible if you have a shared sub-prop Struct that is used by multiple
+// parent Props.
 #ifdef REACT_NATIVE_DEBUG
   bool resetLoop = false;
 #endif
@@ -125,10 +125,7 @@ void RawPropsParser::preparse(const RawProps& rawProps) const noexcept {
 
       for (size_t i = 0; i < count; i++) {
         auto nameValue = names.getValueAtIndex(runtime, i).getString(runtime);
-        auto value = object.getProperty(runtime, nameValue);
-
         auto name = nameValue.utf8(runtime);
-
         auto keyIndex = nameToIndex_.at(
             name.data(), static_cast<RawPropsPropNameLength>(name.size()));
 
@@ -137,6 +134,8 @@ void RawPropsParser::preparse(const RawProps& rawProps) const noexcept {
         }
 
         rawProps.keyIndexToValueIndex_[keyIndex] = valueIndex;
+
+        auto value = object.getProperty(runtime, nameValue);
         rawProps.values_.push_back(
             RawValue(jsi::dynamicFromValue(runtime, value)));
         valueIndex++;
@@ -168,57 +167,4 @@ void RawPropsParser::preparse(const RawProps& rawProps) const noexcept {
   }
 }
 
-/**
- * To be used by RawProps only. Value iterator functions.
- */
-void RawPropsParser::iterateOverValues(
-    const RawProps& rawProps,
-    const std::function<
-        void(RawPropsPropNameHash, const char*, const RawValue&)>& visit)
-    const {
-  switch (rawProps.mode_) {
-    case RawProps::Mode::Empty:
-      return;
-
-    case RawProps::Mode::JSI: {
-      auto& runtime = *rawProps.runtime_;
-      if (!rawProps.value_.isObject()) {
-        LOG(ERROR) << "Preparse props: rawProps value is not object";
-      }
-      react_native_assert(rawProps.value_.isObject());
-      auto object = rawProps.value_.asObject(runtime);
-
-      auto names = object.getPropertyNames(runtime);
-      auto count = names.size(runtime);
-
-      for (size_t i = 0; i < count; i++) {
-        auto nameValue = names.getValueAtIndex(runtime, i).getString(runtime);
-        auto value = object.getProperty(runtime, nameValue);
-
-        auto name = nameValue.utf8(runtime);
-
-        auto nameHash = RAW_PROPS_KEY_HASH(name);
-        auto rawValue = RawValue(jsi::dynamicFromValue(runtime, value));
-
-        visit(nameHash, name.c_str(), rawValue);
-      }
-
-      break;
-    }
-
-    case RawProps::Mode::Dynamic: {
-      const auto& dynamic = rawProps.dynamic_;
-
-      for (const auto& pair : dynamic.items()) {
-        auto name = pair.first.getString();
-
-        auto nameHash = RAW_PROPS_KEY_HASH(name);
-        auto rawValue = RawValue{pair.second};
-        visit(nameHash, name.c_str(), rawValue);
-      }
-      break;
-    }
-  }
-}
-
 } // namespace facebook::react

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

@@ -73,15 +73,6 @@ class RawPropsParser final {
   const RawValue* at(const RawProps& rawProps, const RawPropsKey& key)
       const noexcept;
 
-  /**
-   * To be used by RawProps only. Value iterator functions.
-   */
-  void iterateOverValues(
-      const RawProps& rawProps,
-      const std::function<
-          void(RawPropsPropNameHash, const char*, const RawValue&)>& visit)
-      const;
-
   mutable std::vector<RawPropsKey> keys_{};
   mutable RawPropsKeyMap nameToIndex_{};
   mutable bool ready_{false};

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

@@ -65,18 +65,17 @@ class RawValue {
     return *this;
   }
 
+  explicit RawValue(const folly::dynamic& dynamic) noexcept
+      : dynamic_(dynamic) {}
+
+  explicit RawValue(folly::dynamic&& dynamic) noexcept
+      : dynamic_(std::move(dynamic)) {}
+
  private:
   friend class RawProps;
   friend class RawPropsParser;
   friend class UIManagerBinding;
 
-  /*
-   * Arbitrary constructors are private only for RawProps and internal usage.
-   */
-  RawValue(const folly::dynamic& dynamic) noexcept : dynamic_(dynamic) {}
-
-  RawValue(folly::dynamic&& dynamic) noexcept : dynamic_(std::move(dynamic)) {}
-
   /*
    * Copy constructor and copy assignment operator would be private and only for
    * internal use, but it's needed for user-code that does `auto val =

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

@@ -310,7 +310,8 @@ bool ShadowNode::progressStateIfNecessary() {
 }
 
 void ShadowNode::setRuntimeShadowNodeReference(
-    ShadowNodeWrapper* runtimeShadowNodeReference) const {
+    const std::shared_ptr<ShadowNodeWrapper>& runtimeShadowNodeReference)
+    const {
   runtimeShadowNodeReference_ = runtimeShadowNodeReference;
 }
 
@@ -319,8 +320,8 @@ void ShadowNode::transferRuntimeShadowNodeReference(
   destinationShadowNode->runtimeShadowNodeReference_ =
       runtimeShadowNodeReference_;
 
-  if (runtimeShadowNodeReference_ != nullptr) {
-    runtimeShadowNodeReference_->shadowNode = destinationShadowNode;
+  if (auto reference = runtimeShadowNodeReference_.lock()) {
+    reference->shadowNode = destinationShadowNode;
   }
 }
 
@@ -410,7 +411,7 @@ SharedDebugStringConvertibleList ShadowNode::getDebugProps() const {
 }
 #endif
 
-// Explicitly define destructors here, as they need to exist in order to act as
+// Explicitly define destructors here, as they have to exist in order to act as
 // a "key function" for the ShadowNodeWrapper class -- this allows for RTTI to
 // work properly across dynamic library boundaries (i.e. dynamic_cast that is
 // used by getNativeState method)

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

@@ -190,11 +190,11 @@ class ShadowNode : public Sealable,
   bool progressStateIfNecessary();
 
   /*
-   * Bind the runtime reference to this `ShadowNode` with a raw pointer,
+   * Bind the runtime reference to this `ShadowNode` with a weak pointer,
    * allowing to update the reference to this `ShadowNode` when cloned.
    */
-  void setRuntimeShadowNodeReference(
-      ShadowNodeWrapper* runtimeShadowNodeReference) const;
+  void setRuntimeShadowNodeReference(const std::shared_ptr<ShadowNodeWrapper>&
+                                         runtimeShadowNodeReference) const;
 
   /*
    * Transfer the runtime reference to this `ShadowNode` to a new instance,
@@ -269,9 +269,9 @@ class ShadowNode : public Sealable,
   ShadowNodeTraits traits_;
 
   /*
-   * Pointer to the runtime reference to this `ShadowNode`.
+   * Weak pointer to the runtime reference to this `ShadowNode`.
    */
-  mutable ShadowNodeWrapper* runtimeShadowNodeReference_{};
+  mutable std::weak_ptr<ShadowNodeWrapper> runtimeShadowNodeReference_{};
 };
 
 static_assert(

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

@@ -75,6 +75,9 @@ class ShadowNodeTraits {
 
     // Indicates that direct children of the node should not be collapsed
     ChildrenFormStackingContext = 1 << 10,
+
+    // Inherits `YogaLayoutableShadowNode` and has a custom baseline function.
+    BaselineYogaNode = 1 << 11,
   };
 
   /*

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

@@ -11,6 +11,7 @@
 #include <react/renderer/core/EventLogger.h>
 #include <react/renderer/core/EventPipe.h>
 #include <react/renderer/core/EventQueueProcessor.h>
+#include <react/renderer/core/EventTarget.h>
 #include <react/renderer/core/StatePipe.h>
 #include <react/renderer/core/ValueFactoryEventPayload.h>
 
@@ -20,7 +21,8 @@
 namespace facebook::react {
 
 class MockEventLogger : public EventLogger {
-  EventTag onEventStart(std::string_view /*name*/) override {
+  EventTag onEventStart(std::string_view /*name*/, SharedEventTarget /*target*/)
+      override {
     return EMPTY_EVENT_TAG;
   }
   void onEventProcessingStart(EventTag /*tag*/) override {}

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

@@ -21,10 +21,12 @@ TEST(EventTargetTests, getInstanceHandle) {
 
   EXPECT_EQ(instanceHandle->getTag(), 1);
 
-  auto eventTarget = EventTarget(std::move(instanceHandle));
+  auto eventTarget = EventTarget(std::move(instanceHandle), 41);
 
   EXPECT_EQ(eventTarget.getTag(), 1);
 
+  EXPECT_EQ(eventTarget.getSurfaceId(), 41);
+
   EXPECT_TRUE(eventTarget.getInstanceHandle(*runtime).isNull());
 
   eventTarget.retain(*runtime);