react-native-windows 0.71.10 → 0.72.0-preview.2

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/LongLivedObject.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// [Windows - see issue #11019, this file is an older version]
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <unordered_set>
+
+namespace facebook {
+namespace react {
+
+/**
+ * A simple wrapper class that can be registered to a collection that keep it
+ * alive for extended period of time. This object can be removed from the
+ * collection when needed.
+ *
+ * The subclass of this class must be created using std::make_shared<T>().
+ * After creation, add it to the `LongLivedObjectCollection`.
+ * When done with the object, call `allowRelease()` to allow the OS to release
+ * it.
+ */
+class LongLivedObject {
+ public:
+  virtual void allowRelease();
+
+ protected:
+  LongLivedObject();
+  virtual ~LongLivedObject();
+};
+
+/**
+ * A singleton, thread-safe, write-only collection for the `LongLivedObject`s.
+ */
+class LongLivedObjectCollection {
+ public:
+  static LongLivedObjectCollection &get();
+
+  LongLivedObjectCollection();
+  LongLivedObjectCollection(LongLivedObjectCollection const &) = delete;
+  void operator=(LongLivedObjectCollection const &) = delete;
+
+  void add(std::shared_ptr<LongLivedObject> o) const;
+  void remove(const LongLivedObject *o) const;
+  void clear() const;
+  size_t size() const;
+
+ private:
+  mutable std::unordered_set<std::shared_ptr<LongLivedObject>> collection_;
+  mutable std::mutex collectionMutex_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModuleBinding.cpp

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// [Windows - see issue #11019, this file is an older version]
+
+#include "TurboModuleBinding.h"
+#include <stdexcept>
+#include <string>
+#include <ReactCommon/LongLivedObject.h>
+#include <cxxreact/SystraceSection.h>
+using namespace facebook;
+namespace facebook {
+namespace react {
+/**
+ * Public API to install the TurboModule system.
+ */
+
+TurboModuleBinding::TurboModuleBinding(
+    const TurboModuleProviderFunctionType &&moduleProvider,
+    TurboModuleBindingMode bindingMode,
+    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection)
+    : moduleProvider_(std::move(moduleProvider)),
+      longLivedObjectCollection_(std::move(longLivedObjectCollection)),
+      bindingMode_(bindingMode) {}
+
+void TurboModuleBinding::install(
+    jsi::Runtime &runtime,
+    const TurboModuleProviderFunctionType &&moduleProvider,
+    TurboModuleBindingMode bindingMode,
+    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection) {
+  runtime.global().setProperty(
+      runtime,
+      "__turboModuleProxy",
+      jsi::Function::createFromHostFunction(
+          runtime,
+          jsi::PropNameID::forAscii(runtime, "__turboModuleProxy"),
+          1,
+          [binding = TurboModuleBinding(
+               std::move(moduleProvider),
+               bindingMode,
+               std::move(longLivedObjectCollection))](
+              jsi::Runtime &rt,
+              const jsi::Value &thisVal,
+              const jsi::Value *args,
+              size_t count) mutable {
+            return binding.getModule(rt, thisVal, args, count);
+          }));
+}
+
+TurboModuleBinding::~TurboModuleBinding() {
+  if (longLivedObjectCollection_) {
+    longLivedObjectCollection_->clear();
+  } else {
+    LongLivedObjectCollection::get().clear();
+  }
+}
+
+jsi::Value TurboModuleBinding::getModule(
+    jsi::Runtime &runtime,
+    const jsi::Value &thisVal,
+    const jsi::Value *args,
+    size_t count) {
+  if (count < 1) {
+    throw std::invalid_argument(
+        "__turboModuleProxy must be called with at least 1 argument");
+  }
+  std::string moduleName = args[0].getString(runtime).utf8(runtime);
+  std::shared_ptr<TurboModule> module;
+  {
+    SystraceSection s(
+        "TurboModuleBinding::moduleProvider", "module", moduleName);
+    module = moduleProvider_(moduleName);
+  }
+  if (module) {
+    // Default behaviour
+    if (bindingMode_ == TurboModuleBindingMode::HostObject) {
+      return jsi::Object::createFromHostObject(runtime, std::move(module));
+    }
+
+    auto &weakJsRepresentation = module->jsRepresentation_;
+    if (weakJsRepresentation) {
+      auto jsRepresentation = weakJsRepresentation->lock(runtime);
+      if (!jsRepresentation.isUndefined()) {
+        return jsRepresentation;
+      }
+    }
+
+    // No JS representation found, or object has been collected
+    jsi::Object jsRepresentation(runtime);
+    weakJsRepresentation =
+        std::make_unique<jsi::WeakObject>(runtime, jsRepresentation);
+
+    if (bindingMode_ == TurboModuleBindingMode::Prototype) {
+      // Option 1: create plain object, with it's prototype mapped back to the
+      // hostobject. Any properties accessed are stored on the plain object
+      auto hostObject =
+          jsi::Object::createFromHostObject(runtime, std::move(module));
+      jsRepresentation.setProperty(runtime, "__proto__", std::move(hostObject));
+    } else {
+      // Option 2: eagerly install all hostfunctions at this point, avoids
+      // prototype
+      for (auto &propName : module->getPropertyNames(runtime)) {
+        module->get(runtime, propName);
+      }
+    }
+    return jsRepresentation;
+  } else {
+    return jsi::Value::null();
+  }
+}
+} // namespace react
+} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModuleBinding.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// [Windows - see issue #11019, this file is an older version]
+
+#pragma once
+#include <string>
+#include <ReactCommon/LongLivedObject.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+namespace facebook {
+namespace react {
+
+class JSCallInvoker;
+
+enum class TurboModuleBindingMode : uint8_t {
+  HostObject = 0,
+  Prototype = 1,
+  Eager = 2,
+};
+/**
+ * Represents the JavaScript binding for the TurboModule system.
+ */
+class TurboModuleBinding {
+ public:
+  /*
+   * Installs TurboModuleBinding into JavaScript runtime.
+   * Thread synchronization must be enforced externally.
+   */
+  static void install(
+      jsi::Runtime &runtime,
+      const TurboModuleProviderFunctionType &&moduleProvider,
+      TurboModuleBindingMode bindingMode,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
+
+ private:
+  TurboModuleBinding(
+      const TurboModuleProviderFunctionType &&moduleProvider,
+      TurboModuleBindingMode bindingMode,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
+  virtual ~TurboModuleBinding();
+
+  /**
+   * A lookup function exposed to JS to get an instance of a TurboModule
+   * for the given name.
+   */
+  jsi::Value getModule(
+      jsi::Runtime &runtime,
+      const jsi::Value &thisVal,
+      const jsi::Value *args,
+      size_t count);
+
+  TurboModuleProviderFunctionType moduleProvider_;
+  std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
+  TurboModuleBindingMode bindingMode_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModuleUtils.h

@@ -14,7 +14,6 @@
 
 #include <ReactCommon/CallInvoker.h>
 #include <CallbackWrapper.h>
-#include <LongLivedObject.h>
 
 namespace facebook {
 namespace react {
@@ -37,7 +36,7 @@ using PromiseSetupFunctionType =
     std::function<void(jsi::Runtime &rt, std::shared_ptr<Promise>)>;
 jsi::Value createPromiseAsJSIValue(
     jsi::Runtime &rt,
-    const PromiseSetupFunctionType func);
+    PromiseSetupFunctionType &&func);
 
 class RAIICallbackWrapperDestroyer {
  public:
@@ -59,3 +58,4 @@ class RAIICallbackWrapperDestroyer {
 
 } // namespace react
 } // namespace facebook
+

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

@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "TouchEventEmitter.h"
+
+namespace facebook::react {
+
+#pragma mark - Touches
+
+static void setTouchPayloadOnObject(
+    jsi::Object &object,
+    jsi::Runtime &runtime,
+    Touch const &touch) {
+  object.setProperty(runtime, "locationX", touch.offsetPoint.x);
+  object.setProperty(runtime, "locationY", touch.offsetPoint.y);
+  object.setProperty(runtime, "pageX", touch.pagePoint.x);
+  object.setProperty(runtime, "pageY", touch.pagePoint.y);
+  object.setProperty(runtime, "screenX", touch.screenPoint.x);
+  object.setProperty(runtime, "screenY", touch.screenPoint.y);
+  object.setProperty(runtime, "identifier", touch.identifier);
+  object.setProperty(runtime, "target", touch.target);
+  object.setProperty(runtime, "timestamp", touch.timestamp * 1000);
+  object.setProperty(runtime, "force", touch.force);
+}
+
+static jsi::Value touchesPayload(
+    jsi::Runtime &runtime,
+    Touches const &touches) {
+  auto array = jsi::Array(runtime, touches.size());
+  int i = 0;
+  for (auto const &touch : touches) {
+    auto object = jsi::Object(runtime);
+    setTouchPayloadOnObject(object, runtime, touch);
+    array.setValueAtIndex(runtime, i++, object);
+  }
+  return array;
+}
+
+static jsi::Value touchEventPayload(
+    jsi::Runtime &runtime,
+    TouchEvent const &event) {
+  auto object = jsi::Object(runtime);
+  object.setProperty(
+      runtime, "touches", touchesPayload(runtime, event.touches));
+  object.setProperty(
+      runtime, "changedTouches", touchesPayload(runtime, event.changedTouches));
+  object.setProperty(
+      runtime, "targetTouches", touchesPayload(runtime, event.targetTouches));
+
+  if (!event.changedTouches.empty()) {
+    auto const &firstChangedTouch = *event.changedTouches.begin();
+    setTouchPayloadOnObject(object, runtime, firstChangedTouch);
+  }
+  return object;
+}
+
+static jsi::Value pointerEventPayload(
+    jsi::Runtime &runtime,
+    PointerEvent const &event) {
+  auto object = jsi::Object(runtime);
+  object.setProperty(runtime, "pointerId", event.pointerId);
+  object.setProperty(runtime, "pressure", event.pressure);
+  object.setProperty(runtime, "pointerType", event.pointerType);
+  object.setProperty(runtime, "clientX", event.clientPoint.x);
+  object.setProperty(runtime, "clientY", event.clientPoint.y);
+  // x/y are an alias to clientX/Y
+  object.setProperty(runtime, "x", event.clientPoint.x);
+  object.setProperty(runtime, "y", event.clientPoint.y);
+  // since RN doesn't have a scrollable root, pageX/Y will always equal
+  // clientX/Y
+  object.setProperty(runtime, "pageX", event.clientPoint.x);
+  object.setProperty(runtime, "pageY", event.clientPoint.y);
+  object.setProperty(runtime, "screenX", event.screenPoint.x);
+  object.setProperty(runtime, "screenY", event.screenPoint.y);
+  object.setProperty(runtime, "offsetX", event.offsetPoint.x);
+  object.setProperty(runtime, "offsetY", event.offsetPoint.y);
+  object.setProperty(runtime, "width", event.width);
+  object.setProperty(runtime, "height", event.height);
+  object.setProperty(runtime, "tiltX", event.tiltX);
+  object.setProperty(runtime, "tiltY", event.tiltY);
+  object.setProperty(runtime, "detail", event.detail);
+  object.setProperty(runtime, "buttons", event.buttons);
+  object.setProperty(runtime, "tangentialPressure", event.tangentialPressure);
+  object.setProperty(runtime, "twist", event.twist);
+  object.setProperty(runtime, "ctrlKey", event.ctrlKey);
+  object.setProperty(runtime, "shiftKey", event.shiftKey);
+  object.setProperty(runtime, "altKey", event.altKey);
+  object.setProperty(runtime, "metaKey", event.metaKey);
+  object.setProperty(runtime, "isPrimary", event.isPrimary);
+  object.setProperty(runtime, "button", event.button);
+  return object;
+}
+
+void TouchEventEmitter::dispatchTouchEvent(
+    std::string type,
+    TouchEvent const &event,
+    EventPriority priority,
+    RawEvent::Category category) const {
+  dispatchEvent(
+      std::move(type),
+      [event](jsi::Runtime &runtime) {
+        return touchEventPayload(runtime, event);
+      },
+      priority,
+      category);
+}
+
+void TouchEventEmitter::dispatchPointerEvent(
+    std::string type,
+    PointerEvent const &event,
+    EventPriority priority,
+    RawEvent::Category category) const {
+  dispatchEvent(
+      std::move(type),
+      [event](jsi::Runtime &runtime) {
+        return pointerEventPayload(runtime, event);
+      },
+      priority,
+      category);
+}
+
+void TouchEventEmitter::onTouchStart(TouchEvent const &event) const {
+  dispatchTouchEvent(
+      "touchStart",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onTouchMove(TouchEvent const &event) const {
+  dispatchUniqueEvent("touchMove", [event](jsi::Runtime &runtime) {
+    return touchEventPayload(runtime, event);
+  });
+}
+
+void TouchEventEmitter::onTouchEnd(TouchEvent const &event) const {
+  dispatchTouchEvent(
+      "touchEnd",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onTouchCancel(TouchEvent const &event) const {
+  dispatchTouchEvent(
+      "touchCancel",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onPointerCancel(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerCancel",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onPointerDown(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerDown",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onPointerMove(const PointerEvent &event) const {
+  dispatchUniqueEvent("pointerMove", [event](jsi::Runtime &runtime) {
+    return pointerEventPayload(runtime, event);
+  });
+}
+
+void TouchEventEmitter::onPointerUp(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerUp",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onPointerEnter(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerEnter",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onPointerLeave(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerLeave",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
+}
+
+void TouchEventEmitter::onPointerOver(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerOver",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onPointerOut(const PointerEvent &event) const {
+  dispatchPointerEvent(
+      "pointerOut",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+// [Windows
+void TouchEventEmitter::onMouseEnter(PointerEvent const &event) const {
+    dispatchPointerEvent(
+      "mouseEnter",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+
+void TouchEventEmitter::onMouseLeave(PointerEvent const &event) const {
+    dispatchPointerEvent(
+      "mouseLeave",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
+}
+// Windows]
+
+
+} // namespace facebook::react

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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/components/view/PointerEvent.h>
+#include <react/renderer/components/view/TouchEvent.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/debug/DebugStringConvertible.h>
+
+namespace facebook {
+namespace react {
+
+class TouchEventEmitter;
+
+using SharedTouchEventEmitter = std::shared_ptr<TouchEventEmitter const>;
+
+class TouchEventEmitter : public EventEmitter {
+ public:
+  using EventEmitter::EventEmitter;
+
+  void onTouchStart(TouchEvent const &event) const;
+  void onTouchMove(TouchEvent const &event) const;
+  void onTouchEnd(TouchEvent const &event) const;
+  void onTouchCancel(TouchEvent const &event) const;
+
+  void onPointerCancel(PointerEvent const &event) const;
+  void onPointerDown(PointerEvent const &event) const;
+  void onPointerMove(PointerEvent const &event) const;
+  void onPointerUp(PointerEvent const &event) const;
+  void onPointerEnter(PointerEvent const &event) const;
+  void onPointerLeave(PointerEvent const &event) const;
+  void onPointerOver(PointerEvent const &event) const;
+  void onPointerOut(PointerEvent const &event) const;
+
+  void onMouseEnter(PointerEvent const &event) const; // [Windows]
+  void onMouseLeave(PointerEvent const &event) const; // [Windows]
+
+ private:
+  void dispatchTouchEvent(
+      std::string type,
+      TouchEvent const &event,
+      EventPriority priority,
+      RawEvent::Category category) const;
+  void dispatchPointerEvent(
+      std::string type,
+      PointerEvent const &event,
+      EventPriority priority,
+      RawEvent::Category category) const;
+};
+
+} // namespace react
+} // namespace facebook