react-native-windows 0.76.3 → 0.77.0-preview.1

package/Microsoft.ReactNative.Cxx/NodeApiJsiRuntime.h

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+#ifndef NODEAPIJSIRUNTIME_H_
+#define NODEAPIJSIRUNTIME_H_
+
+#include <jsi/jsi.h>
+#include <functional>
+#include <memory>
+#include "ApiLoaders/JSRuntimeApi.h"
+
+namespace Microsoft::NodeApiJsi {
+
+std::unique_ptr<facebook::jsi::Runtime>
+makeNodeApiJsiRuntime(napi_env env, JSRuntimeApi *jsrApi, std::function<void()> onDelete) noexcept;
+
+struct NodeApiEnvScope {
+  NodeApiEnvScope(napi_env env) : env_(env) {
+    JSRuntimeApi::current()->jsr_open_napi_env_scope(env, &scope_);
+  }
+
+  NodeApiEnvScope(const NodeApiEnvScope &) = delete;
+  NodeApiEnvScope &operator=(const NodeApiEnvScope &) = delete;
+
+  ~NodeApiEnvScope() {
+    JSRuntimeApi::current()->jsr_close_napi_env_scope(env_, scope_);
+  }
+
+ private:
+  napi_env env_{};
+  jsr_napi_env_scope scope_{};
+};
+} // namespace Microsoft::NodeApiJsi
+
+#endif // !NODEAPIJSIRUNTIME_H_

package/Microsoft.ReactNative.Cxx/ReactCommon/CallInvoker.h

@@ -0,0 +1,64 @@
+/*
+ * 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 <functional>
+#include <memory>
+
+#include "SchedulerPriority.h"
+
+namespace facebook::jsi {
+class Runtime;
+}
+
+namespace facebook::react {
+
+using CallFunc = std::function<void(jsi::Runtime&)>;
+
+/**
+ * An interface for a generic native-to-JS call invoker. See BridgeJSCallInvoker
+ * for an implementation.
+ */
+class CallInvoker {
+ public:
+  virtual void invokeAsync(CallFunc&& func) noexcept = 0;
+  virtual void invokeAsync(
+      SchedulerPriority /*priority*/,
+      CallFunc&& func) noexcept {
+    // When call with priority is not implemented, fall back to a regular async
+    // execution
+    invokeAsync(std::move(func));
+  }
+  virtual void invokeSync(CallFunc&& func) = 0;
+
+  // Backward compatibility only, prefer the CallFunc methods instead
+  virtual void invokeAsync(std::function<void()>&& func) noexcept {
+    invokeAsync([func](jsi::Runtime&) { func(); });
+  }
+
+  virtual void invokeSync(std::function<void()>&& func) {
+    invokeSync([func](jsi::Runtime&) { func(); });
+  }
+
+  virtual ~CallInvoker() {}
+};
+
+using NativeMethodCallFunc = std::function<void()>;
+
+class NativeMethodCallInvoker {
+ public:
+  virtual void invokeAsync(
+      const std::string& methodName,
+      NativeMethodCallFunc&& func) noexcept = 0;
+  virtual void invokeSync(
+      const std::string& methodName,
+      NativeMethodCallFunc&& func) = 0;
+  virtual ~NativeMethodCallInvoker() {}
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/SchedulerPriority.h

@@ -0,0 +1,22 @@
+/*
+ * 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 <chrono>
+
+namespace facebook::react {
+
+enum class SchedulerPriority : int {
+  ImmediatePriority = 1,
+  UserBlockingPriority = 2,
+  NormalPriority = 3,
+  LowPriority = 4,
+  IdlePriority = 5,
+};
+
+} // namespace facebook::react

package/{ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core → Microsoft.ReactNative.Cxx}/ReactCommon/TurboModule.cpp

@@ -1,63 +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.
- */
-
-#include "TurboModule.h"
-//#include <react/debug/react_native_assert.h>
-
-namespace facebook::react {
-
-TurboModuleMethodValueKind getTurboModuleMethodValueKind(
-    jsi::Runtime& rt,
-    const jsi::Value* value) {
-  if (!value || value->isUndefined() || value->isNull()) {
-    return VoidKind;
-  } else if (value->isBool()) {
-    return BooleanKind;
-  } else if (value->isNumber()) {
-    return NumberKind;
-  } else if (value->isString()) {
-    return StringKind;
-  } else if (value->isObject()) {
-    auto object = value->asObject(rt);
-    if (object.isArray(rt)) {
-      return ArrayKind;
-    } else if (object.isFunction(rt)) {
-      return FunctionKind;
-    }
-    return ObjectKind;
-  }
-  //react_native_assert(false && "Unsupported jsi::Value kind");
-  return VoidKind;
-}
-
-TurboModule::TurboModule(
-    std::string name,
-    std::shared_ptr<CallInvoker> jsInvoker)
-    : name_(std::move(name)), jsInvoker_(std::move(jsInvoker)) {}
-
-void TurboModule::emitDeviceEvent(
-    const std::string& eventName,
-    ArgFactory argFactory) {
-  jsInvoker_->invokeAsync([eventName, argFactory](jsi::Runtime& rt) {
-    jsi::Value emitter = rt.global().getProperty(rt, "__rctDeviceEventEmitter");
-    if (!emitter.isUndefined()) {
-      jsi::Object emitterObject = emitter.asObject(rt);
-      // TODO: consider caching these
-      jsi::Function emitFunction =
-          emitterObject.getPropertyAsFunction(rt, "emit");
-      std::vector<jsi::Value> args;
-      args.emplace_back(jsi::String::createFromAscii(rt, eventName.c_str()));
-      if (argFactory) {
-        argFactory(rt, args);
-      }
-      emitFunction.callWithThis(
-          rt, emitterObject, (const jsi::Value*)args.data(), args.size());
-    }
-  });
-}
-
-} // namespace facebook::react
+/*
+ * 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 "TurboModule.h"
+#include <react/debug/react_native_assert.h>
+
+namespace facebook::react {
+
+TurboModuleMethodValueKind getTurboModuleMethodValueKind(
+    jsi::Runtime& rt,
+    const jsi::Value* value) {
+  if (!value || value->isUndefined() || value->isNull()) {
+    return VoidKind;
+  } else if (value->isBool()) {
+    return BooleanKind;
+  } else if (value->isNumber()) {
+    return NumberKind;
+  } else if (value->isString()) {
+    return StringKind;
+  } else if (value->isObject()) {
+    auto object = value->asObject(rt);
+    if (object.isArray(rt)) {
+      return ArrayKind;
+    } else if (object.isFunction(rt)) {
+      return FunctionKind;
+    }
+    return ObjectKind;
+  }
+  react_native_assert(false && "Unsupported jsi::Value kind");
+  return VoidKind;
+}
+
+TurboModule::TurboModule(
+    std::string name,
+    std::shared_ptr<CallInvoker> jsInvoker)
+    : name_(std::move(name)), jsInvoker_(std::move(jsInvoker)) {}
+
+void TurboModule::emitDeviceEvent(
+    const std::string& eventName,
+    ArgFactory argFactory) {
+  jsInvoker_->invokeAsync([eventName, argFactory](jsi::Runtime& rt) {
+    jsi::Value emitter = rt.global().getProperty(rt, "__rctDeviceEventEmitter");
+    if (!emitter.isUndefined()) {
+      jsi::Object emitterObject = emitter.asObject(rt);
+      // TODO: consider caching these
+      jsi::Function emitFunction =
+          emitterObject.getPropertyAsFunction(rt, "emit");
+      std::vector<jsi::Value> args;
+      args.emplace_back(jsi::String::createFromAscii(rt, eventName.c_str()));
+      if (argFactory) {
+        argFactory(rt, args);
+      }
+      emitFunction.callWithThis(
+          rt, emitterObject, (const jsi::Value*)args.data(), args.size());
+    }
+  });
+}
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/TurboModule.h

@@ -0,0 +1,165 @@
+/*
+ * 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 <memory>
+#include <string>
+#include <unordered_map>
+
+#include <jsi/jsi.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <react/bridging/EventEmitter.h>
+
+namespace facebook::react {
+
+/**
+ * For now, support the same set of return types as existing impl.
+ * This can be improved to support richer typed objects.
+ */
+enum TurboModuleMethodValueKind {
+  VoidKind,
+  BooleanKind,
+  NumberKind,
+  StringKind,
+  ObjectKind,
+  ArrayKind,
+  FunctionKind,
+  PromiseKind,
+};
+
+/**
+ * Determines TurboModuleMethodValueKind based on the jsi::Value type.
+ */
+TurboModuleMethodValueKind getTurboModuleMethodValueKind(
+    jsi::Runtime& rt,
+    const jsi::Value* value);
+
+class TurboCxxModule;
+class TurboModuleBinding;
+
+/**
+ * Base HostObject class for every module to be exposed to JS
+ */
+class JSI_EXPORT TurboModule : public jsi::HostObject {
+ public:
+  TurboModule(std::string name, std::shared_ptr<CallInvoker> jsInvoker);
+
+  // DO NOT OVERRIDE - it will become final in a future release.
+  // This method provides automatic caching of properties on the TurboModule's
+  // JS representation. To customize lookup of properties, override `create`.
+  // Note: keep this method declared inline to avoid conflicts
+  // between RTTI and non-RTTI compilation units
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName)
+      override {
+    auto prop = create(runtime, propName);
+    // If we have a JS wrapper, cache the result of this lookup
+    // We don't cache misses, to allow for methodMap_ to dynamically be
+    // extended
+    // [Windows] Reenable once https://github.com/microsoft/react-native-windows/issues/14128 is fixed
+#ifndef WINAPI_FAMILY
+    if (jsRepresentation_ && !prop.isUndefined()) {
+      jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
+          runtime, propName, prop);
+    }
+#endif
+    return prop;
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(
+      jsi::Runtime& runtime) override {
+    std::vector<jsi::PropNameID> result;
+    result.reserve(methodMap_.size());
+    for (auto it = methodMap_.cbegin(); it != methodMap_.cend(); ++it) {
+      result.push_back(jsi::PropNameID::forUtf8(runtime, it->first));
+    }
+    return result;
+  }
+
+ protected:
+  const std::string name_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+
+  struct MethodMetadata {
+    size_t argCount;
+    jsi::Value (*invoker)(
+        jsi::Runtime& rt,
+        TurboModule& turboModule,
+        const jsi::Value* args,
+        size_t count);
+  };
+  std::unordered_map<std::string, MethodMetadata> methodMap_;
+  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
+      eventEmitterMap_;
+
+  using ArgFactory =
+      std::function<void(jsi::Runtime& runtime, std::vector<jsi::Value>& args)>;
+
+  /**
+   * Calls RCTDeviceEventEmitter.emit to JavaScript, with given event name and
+   * an optional list of arguments.
+   * If present, argFactory is a callback used to construct extra arguments,
+   * e.g.
+   *
+   *  emitDeviceEvent(rt, "myCustomEvent",
+   *    [](jsi::Runtime& rt, std::vector<jsi::Value>& args) {
+   *      args.emplace_back(jsi::Value(true));
+   *      args.emplace_back(jsi::Value(42));
+   *  });
+   */
+  void emitDeviceEvent(
+      const std::string& eventName,
+      ArgFactory argFactory = nullptr);
+
+  // Backwards compatibility version
+  void emitDeviceEvent(
+      jsi::Runtime& /*runtime*/,
+
+      const std::string& eventName,
+      ArgFactory argFactory = nullptr) {
+    emitDeviceEvent(eventName, std::move(argFactory));
+  }
+
+  virtual jsi::Value create(
+      jsi::Runtime& runtime,
+      const jsi::PropNameID& propName) {
+    std::string propNameUtf8 = propName.utf8(runtime);
+    if (auto methodIter = methodMap_.find(propNameUtf8);
+        methodIter != methodMap_.end()) {
+      const MethodMetadata& meta = methodIter->second;
+      return jsi::Function::createFromHostFunction(
+          runtime,
+          propName,
+          static_cast<unsigned int>(meta.argCount),
+          [this, meta](
+              jsi::Runtime& rt,
+              [[maybe_unused]] const jsi::Value& thisVal,
+              const jsi::Value* args,
+              size_t count) { return meta.invoker(rt, *this, args, count); });
+    } else if (auto eventEmitterIter = eventEmitterMap_.find(propNameUtf8);
+               eventEmitterIter != eventEmitterMap_.end()) {
+      return eventEmitterIter->second->get(runtime, jsInvoker_);
+    } else {
+      // Neither Method nor EventEmitter were found, let JS decide what to do
+      return jsi::Value::undefined();
+    }
+  }
+
+ private:
+  friend class TurboModuleBinding;
+  std::unique_ptr<jsi::WeakObject> jsRepresentation_;
+};
+
+/**
+ * An app/platform-specific provider function to get an instance of a module
+ * given a name.
+ */
+using TurboModuleProviderFunctionType =
+    std::function<std::shared_ptr<TurboModule>(const std::string& name)>;
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/TurboModuleUtils.cpp

@@ -0,0 +1,105 @@
+/*
+ * 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 "TurboModuleUtils.h"
+
+namespace facebook::react {
+
+static jsi::Value deepCopyJSIValue(jsi::Runtime& rt, const jsi::Value& value) {
+  if (value.isNull()) {
+    return jsi::Value::null();
+  }
+
+  if (value.isBool()) {
+    return jsi::Value(value.getBool());
+  }
+
+  if (value.isNumber()) {
+    return jsi::Value(value.getNumber());
+  }
+
+  if (value.isString()) {
+    return value.getString(rt);
+  }
+
+  if (value.isObject()) {
+    jsi::Object o = value.getObject(rt);
+    if (o.isArray(rt)) {
+      return deepCopyJSIArray(rt, o.getArray(rt));
+    }
+    if (o.isFunction(rt)) {
+      return o.getFunction(rt);
+    }
+    return deepCopyJSIObject(rt, o);
+  }
+
+  return jsi::Value::undefined();
+}
+
+jsi::Object deepCopyJSIObject(jsi::Runtime& rt, const jsi::Object& obj) {
+  jsi::Object copy(rt);
+  jsi::Array propertyNames = obj.getPropertyNames(rt);
+  size_t size = propertyNames.size(rt);
+  for (size_t i = 0; i < size; i++) {
+    jsi::String name = propertyNames.getValueAtIndex(rt, i).getString(rt);
+    jsi::Value value = obj.getProperty(rt, name);
+    copy.setProperty(rt, name, deepCopyJSIValue(rt, value));
+  }
+  return copy;
+}
+
+jsi::Array deepCopyJSIArray(jsi::Runtime& rt, const jsi::Array& arr) {
+  size_t size = arr.size(rt);
+  jsi::Array copy(rt, size);
+  for (size_t i = 0; i < size; i++) {
+    copy.setValueAtIndex(
+        rt, i, deepCopyJSIValue(rt, arr.getValueAtIndex(rt, i)));
+  }
+  return copy;
+}
+
+Promise::Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject)
+    : LongLivedObject(rt),
+      resolve_(std::move(resolve)),
+      reject_(std::move(reject)) {}
+
+void Promise::resolve(const jsi::Value& result) {
+  resolve_.call(runtime_, result);
+}
+
+void Promise::reject(const std::string& message) {
+  jsi::Object error(runtime_);
+  error.setProperty(
+      runtime_, "message", jsi::String::createFromUtf8(runtime_, message));
+  reject_.call(runtime_, error);
+}
+
+jsi::Value createPromiseAsJSIValue(
+    jsi::Runtime& rt,
+    PromiseSetupFunctionType&& func) {
+  jsi::Function JSPromise = rt.global().getPropertyAsFunction(rt, "Promise");
+  jsi::Function fn = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "fn"),
+      2,
+      [func = std::move(func)](
+          jsi::Runtime& rt2,
+          const jsi::Value& thisVal,
+          const jsi::Value* args,
+          size_t count) {
+        jsi::Function resolve = args[0].getObject(rt2).getFunction(rt2);
+        jsi::Function reject = args[1].getObject(rt2).getFunction(rt2);
+        auto wrapper = std::make_shared<Promise>(
+            rt2, std::move(resolve), std::move(reject));
+        func(rt2, wrapper);
+        return jsi::Value::undefined();
+      });
+
+  return JSPromise.callAsConstructor(rt, fn);
+}
+
+} // namespace facebook::react

package/{ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core → Microsoft.ReactNative.Cxx}/ReactCommon/TurboModuleUtils.h

@@ -1,58 +1,57 @@
-/*
- * 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 <cassert>
-#include <string>
-
-#include <jsi/jsi.h>
-#include <LongLivedObject.h> // [Windows #13391]
-
-#include <CallbackWrapper.h> // [Windows #13391]
-
-namespace facebook::react {
-
-jsi::Object deepCopyJSIObject(jsi::Runtime& rt, const jsi::Object& obj);
-jsi::Array deepCopyJSIArray(jsi::Runtime& rt, const jsi::Array& arr);
-
-struct Promise : public LongLivedObject {
-  Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject);
-
-  void resolve(const jsi::Value& result);
-  void reject(const std::string& error);
-
-  jsi::Function resolve_;
-  jsi::Function reject_;
-};
-
-using PromiseSetupFunctionType =
-    std::function<void(jsi::Runtime& rt, std::shared_ptr<Promise>)>;
-jsi::Value createPromiseAsJSIValue(
-    jsi::Runtime& rt,
-    PromiseSetupFunctionType&& func);
-
-// Deprecated. Use AsyncCallback instead.
-class RAIICallbackWrapperDestroyer {
- public:
-  RAIICallbackWrapperDestroyer(std::weak_ptr<CallbackWrapper> callbackWrapper)
-      : callbackWrapper_(callbackWrapper) {}
-
-  ~RAIICallbackWrapperDestroyer() {
-    auto strongWrapper = callbackWrapper_.lock();
-    if (!strongWrapper) {
-      return;
-    }
-
-    strongWrapper->destroy();
-  }
-
- private:
-  std::weak_ptr<CallbackWrapper> callbackWrapper_;
-};
-
-} // namespace facebook::react
+/*
+ * 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 <cassert>
+#include <string>
+
+#include <jsi/jsi.h>
+#include <react/bridging/CallbackWrapper.h>
+#include <react/bridging/LongLivedObject.h>
+
+namespace facebook::react {
+
+jsi::Object deepCopyJSIObject(jsi::Runtime& rt, const jsi::Object& obj);
+jsi::Array deepCopyJSIArray(jsi::Runtime& rt, const jsi::Array& arr);
+
+struct Promise : public LongLivedObject {
+  Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject);
+
+  void resolve(const jsi::Value& result);
+  void reject(const std::string& error);
+
+  jsi::Function resolve_;
+  jsi::Function reject_;
+};
+
+using PromiseSetupFunctionType =
+    std::function<void(jsi::Runtime& rt, std::shared_ptr<Promise>)>;
+jsi::Value createPromiseAsJSIValue(
+    jsi::Runtime& rt,
+    PromiseSetupFunctionType&& func);
+
+// Deprecated. Use AsyncCallback instead.
+class RAIICallbackWrapperDestroyer {
+ public:
+  RAIICallbackWrapperDestroyer(std::weak_ptr<CallbackWrapper> callbackWrapper)
+      : callbackWrapper_(callbackWrapper) {}
+
+  ~RAIICallbackWrapperDestroyer() {
+    auto strongWrapper = callbackWrapper_.lock();
+    if (!strongWrapper) {
+      return;
+    }
+
+    strongWrapper->destroy();
+  }
+
+ private:
+  std::weak_ptr<CallbackWrapper> callbackWrapper_;
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/AString.h

@@ -0,0 +1,42 @@
+/*
+ * 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/bridging/Base.h>
+
+#include <string>
+#include <string_view>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<std::string> {
+  static std::string fromJs(jsi::Runtime& rt, const jsi::String& value) {
+    return value.utf8(rt);
+  }
+
+  static jsi::String toJs(jsi::Runtime& rt, const std::string& value) {
+    return jsi::String::createFromUtf8(rt, value);
+  }
+};
+
+template <>
+struct Bridging<std::string_view> {
+  static jsi::String toJs(jsi::Runtime& rt, std::string_view value) {
+    return jsi::String::createFromUtf8(
+        rt, reinterpret_cast<const uint8_t*>(value.data()), value.length());
+  }
+};
+
+template <>
+struct Bridging<const char*> : Bridging<std::string_view> {};
+
+template <size_t N>
+struct Bridging<char[N]> : Bridging<std::string_view> {};
+
+} // namespace facebook::react