react-native-windows 0.80.1 → 0.81.0-preview.1

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

@@ -12,55 +12,57 @@
 namespace facebook::react::bridging {
 
 template <
-    typename T,
-    typename C,
-    typename R,
-    typename... Args,
-    typename... JSArgs>
-T callFromJs(
+    typename JSReturnT,
+    typename ClassT,
+    typename ReturnT,
+    typename... ArgsT,
+    typename... JSArgsT>
+JSReturnT callFromJs(
     jsi::Runtime& rt,
-    R (C::*method)(jsi::Runtime&, Args...),
+    ReturnT (ClassT::*method)(jsi::Runtime&, ArgsT...),
     const std::shared_ptr<CallInvoker>& jsInvoker,
-    C* instance,
-    JSArgs&&... args) {
+    ClassT* instance,
+    JSArgsT&&... args) {
   static_assert(
-      sizeof...(Args) == sizeof...(JSArgs), "Incorrect arguments length");
+      sizeof...(ArgsT) == sizeof...(JSArgsT), "Incorrect arguments length");
   static_assert(
-      (supportsFromJs<Args, JSArgs> && ...), "Incompatible arguments");
+      (supportsFromJs<ArgsT, JSArgsT> && ...), "Incompatible arguments");
 
-  if constexpr (std::is_void_v<T>) {
+  if constexpr (std::is_void_v<JSReturnT>) {
     (instance->*method)(
-        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
 
-  } else if constexpr (std::is_void_v<R>) {
+  } else if constexpr (std::is_void_v<ReturnT>) {
     static_assert(
-        std::is_same_v<T, jsi::Value>,
+        std::is_same_v<JSReturnT, jsi::Value>,
         "Void functions may only return undefined");
 
     (instance->*method)(
-        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
     return jsi::Value();
 
-  } else if constexpr (is_jsi_v<T>) {
-    static_assert(supportsToJs<R, T>, "Incompatible return type");
+  } else if constexpr (
+      is_jsi_v<JSReturnT> || supportsToJs<ReturnT, JSReturnT>) {
+    static_assert(supportsToJs<ReturnT, JSReturnT>, "Incompatible return type");
 
     return toJs(
         rt,
         (instance->*method)(
-            rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...),
+            rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
         jsInvoker);
-
-  } else if constexpr (is_optional_jsi_v<T>) {
+  } else if constexpr (is_optional_jsi_v<JSReturnT>) {
     static_assert(
-        is_optional_v<R>
-            ? supportsToJs<typename R::value_type, typename T::value_type>
-            : supportsToJs<R, typename T::value_type>,
+        is_optional_v<ReturnT>
+            ? supportsToJs<
+                  typename ReturnT::value_type,
+                  typename JSReturnT::value_type>
+            : supportsToJs<ReturnT, typename JSReturnT::value_type>,
         "Incompatible return type");
 
     auto result = toJs(
         rt,
         (instance->*method)(
-            rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...),
+            rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
         jsInvoker);
 
     if constexpr (std::is_same_v<decltype(result), jsi::Value>) {
@@ -71,20 +73,21 @@ T callFromJs(
 
     return convert(rt, std::move(result));
   } else {
-    static_assert(std::is_convertible_v<R, T>, "Incompatible return type");
+    static_assert(
+        std::is_convertible_v<ReturnT, JSReturnT>, "Incompatible return type");
     return (instance->*method)(
-        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+        rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
   }
 }
 
-template <typename R, typename... Args>
-constexpr size_t getParameterCount(R (*)(Args...)) {
-  return sizeof...(Args);
+template <typename ReturnT, typename... ArgsT>
+constexpr size_t getParameterCount(ReturnT (*)(ArgsT...)) {
+  return sizeof...(ArgsT);
 }
 
-template <typename C, typename R, typename... Args>
-constexpr size_t getParameterCount(R (C::*)(Args...)) {
-  return sizeof...(Args);
+template <typename Class, typename ReturnT, typename... ArgsT>
+constexpr size_t getParameterCount(ReturnT (Class::*)(ArgsT...)) {
+  return sizeof...(ArgsT);
 }
 
 } // namespace facebook::react::bridging

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

@@ -13,45 +13,45 @@ namespace facebook::react {
 
 template <>
 struct Bridging<double> {
-  static double fromJs(jsi::Runtime&, const jsi::Value& value) {
+  static double fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
     return value.asNumber();
   }
 
-  static jsi::Value toJs(jsi::Runtime&, double value) {
+  static double toJs(jsi::Runtime& /*unused*/, double value) {
     return value;
   }
 };
 
 template <>
 struct Bridging<float> {
-  static float fromJs(jsi::Runtime&, const jsi::Value& value) {
+  static float fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
     return (float)value.asNumber();
   }
 
-  static jsi::Value toJs(jsi::Runtime&, float value) {
-    return (double)value;
+  static float toJs(jsi::Runtime& /*unused*/, float value) {
+    return value;
   }
 };
 
 template <>
 struct Bridging<int32_t> {
-  static int32_t fromJs(jsi::Runtime&, const jsi::Value& value) {
+  static int32_t fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
     return (int32_t)value.asNumber();
   }
 
-  static jsi::Value toJs(jsi::Runtime&, int32_t value) {
+  static int32_t toJs(jsi::Runtime& /*unused*/, int32_t value) {
     return value;
   }
 };
 
 template <>
 struct Bridging<uint32_t> {
-  static uint32_t fromJs(jsi::Runtime&, const jsi::Value& value) {
+  static uint32_t fromJs(jsi::Runtime& /*unused*/, const jsi::Value& value) {
     return (uint32_t)value.asNumber();
   }
 
-  static jsi::Value toJs(jsi::Runtime&, uint32_t value) {
-    return (double)value;
+  static jsi::Value toJs(jsi::Runtime& /*unused*/, uint32_t value) {
+    return double(value);
   }
 };
 

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

@@ -16,8 +16,12 @@
 
 namespace facebook::react {
 
-template <typename T>
+template <typename... T>
 class AsyncPromise {
+  static_assert(
+      sizeof...(T) <= 1,
+      "AsyncPromise must have at most one argument");
+
  public:
   AsyncPromise(jsi::Runtime& rt, const std::shared_ptr<CallInvoker>& jsInvoker)
       : state_(std::make_shared<SharedState>()) {
@@ -28,7 +32,9 @@ class AsyncPromise {
         bridging::toJs(
             rt,
             // Safe to capture this since this is called synchronously.
-            [this](AsyncCallback<T> resolve, AsyncCallback<Error> reject) {
+            [this](
+                AsyncCallback<T...> resolve,
+                const AsyncCallback<Error>& reject) {
               state_->resolve = std::move(resolve);
               state_->reject = std::move(reject);
             },
@@ -42,11 +48,11 @@ class AsyncPromise {
     state_->promiseHolder = promiseHolder;
   }
 
-  void resolve(T value) {
+  void resolve(T... value) {
     std::lock_guard<std::mutex> lock(state_->mutex);
 
     if (state_->resolve) {
-      state_->resolve->call(std::move(value));
+      state_->resolve->call(std::forward<T>(value)...);
       state_->resolve.reset();
       state_->reject.reset();
     }
@@ -87,16 +93,16 @@ class AsyncPromise {
 
     std::mutex mutex;
     std::weak_ptr<PromiseHolder> promiseHolder;
-    std::optional<AsyncCallback<T>> resolve;
+    std::optional<AsyncCallback<T...>> resolve;
     std::optional<AsyncCallback<Error>> reject;
   };
 
   std::shared_ptr<SharedState> state_;
 };
 
-template <typename T>
-struct Bridging<AsyncPromise<T>> {
-  static jsi::Object toJs(jsi::Runtime& rt, const AsyncPromise<T>& promise) {
+template <typename... T>
+struct Bridging<AsyncPromise<T...>> {
+  static jsi::Object toJs(jsi::Runtime& rt, const AsyncPromise<T...>& promise) {
     return promise.get(rt);
   }
 };

package/Microsoft.ReactNative.Cxx/node-api/js_native_api.h

@@ -21,6 +21,18 @@
 #endif
 #endif
 
+#if defined(NAPI_EXPERIMENTAL) &&                                              \
+    !defined(NODE_API_EXPERIMENTAL_NO_WARNING) &&                              \
+    !defined(NODE_WANT_INTERNALS)
+#ifdef _MSC_VER
+#pragma message("NAPI_EXPERIMENTAL is enabled. "                               \
+                "Experimental features may be unstable.")
+#else
+#warning "NAPI_EXPERIMENTAL is enabled. " \
+       "Experimental features may be unstable."
+#endif
+#endif
+
 #include "js_native_api_types.h"
 
 // If you need __declspec(dllimport), either include <node_api.h> instead, or
@@ -50,7 +62,7 @@
 EXTERN_C_START
 
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info(
-    node_api_nogc_env env, const napi_extended_error_info** result);
+    node_api_basic_env env, const napi_extended_error_info** result);
 
 // Getters for defined singletons
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env,
@@ -92,31 +104,31 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env,
                                                             const char16_t* str,
                                                             size_t length,
                                                             napi_value* result);
-#ifdef NAPI_EXPERIMENTAL
-#define NODE_API_EXPERIMENTAL_HAS_EXTERNAL_STRINGS
-NAPI_EXTERN napi_status NAPI_CDECL
-node_api_create_external_string_latin1(napi_env env,
-                                       char* str,
-                                       size_t length,
-                                       node_api_nogc_finalize finalize_callback,
-                                       void* finalize_hint,
-                                       napi_value* result,
-                                       bool* copied);
+#if NAPI_VERSION >= 10
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1(
+    napi_env env,
+    char* str,
+    size_t length,
+    node_api_basic_finalize finalize_callback,
+    void* finalize_hint,
+    napi_value* result,
+    bool* copied);
 NAPI_EXTERN napi_status NAPI_CDECL
 node_api_create_external_string_utf16(napi_env env,
                                       char16_t* str,
                                       size_t length,
-                                      node_api_nogc_finalize finalize_callback,
+                                      node_api_basic_finalize finalize_callback,
                                       void* finalize_hint,
                                       napi_value* result,
                                       bool* copied);
-#endif  // NAPI_EXPERIMENTAL
 
-#ifdef NAPI_EXPERIMENTAL
-#define NODE_API_EXPERIMENTAL_HAS_PROPERTY_KEYS
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_latin1(
+    napi_env env, const char* str, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf8(
+    napi_env env, const char* str, size_t length, napi_value* result);
 NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf16(
     napi_env env, const char16_t* str, size_t length, napi_value* result);
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION >= 10
 
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(napi_env env,
                                                       napi_value description,
@@ -318,12 +330,13 @@ napi_define_class(napi_env env,
                   napi_value* result);
 
 // Methods to work with external data objects
-NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(napi_env env,
-                                             napi_value js_object,
-                                             void* native_object,
-                                             node_api_nogc_finalize finalize_cb,
-                                             void* finalize_hint,
-                                             napi_ref* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_wrap(napi_env env,
+          napi_value js_object,
+          void* native_object,
+          node_api_basic_finalize finalize_cb,
+          void* finalize_hint,
+          napi_ref* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env,
                                                napi_value js_object,
                                                void** result);
@@ -333,7 +346,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env,
 NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external(napi_env env,
                      void* data,
-                     node_api_nogc_finalize finalize_cb,
+                     node_api_basic_finalize finalize_cb,
                      void* finalize_hint,
                      napi_value* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env,
@@ -432,7 +445,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external_arraybuffer(napi_env env,
                                  void* external_data,
                                  size_t byte_length,
-                                 node_api_nogc_finalize finalize_cb,
+                                 node_api_basic_finalize finalize_cb,
                                  void* finalize_hint,
                                  napi_value* result);
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
@@ -474,7 +487,7 @@ napi_get_dataview_info(napi_env env,
                        size_t* byte_offset);
 
 // version management
-NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_nogc_env env,
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
                                                     uint32_t* result);
 
 // Promises
@@ -498,7 +511,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env,
 
 // Memory management
 NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory(
-    node_api_nogc_env env, int64_t change_in_bytes, int64_t* adjusted_value);
+    node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value);
 
 #if NAPI_VERSION >= 5
 
@@ -520,7 +533,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
 napi_add_finalizer(napi_env env,
                    napi_value js_object,
                    void* finalize_data,
-                   node_api_nogc_finalize finalize_cb,
+                   node_api_basic_finalize finalize_cb,
                    void* finalize_hint,
                    napi_ref* result);
 
@@ -530,7 +543,7 @@ napi_add_finalizer(napi_env env,
 #define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
 
 NAPI_EXTERN napi_status NAPI_CDECL
-node_api_post_finalizer(node_api_nogc_env env,
+node_api_post_finalizer(node_api_basic_env env,
                         napi_finalize finalize_cb,
                         void* finalize_data,
                         void* finalize_hint);
@@ -575,13 +588,13 @@ napi_get_all_property_names(napi_env env,
 
 // Instance data
 NAPI_EXTERN napi_status NAPI_CDECL
-napi_set_instance_data(node_api_nogc_env env,
+napi_set_instance_data(node_api_basic_env env,
                        void* data,
                        napi_finalize finalize_cb,
                        void* finalize_hint);
 
-NAPI_EXTERN napi_status NAPI_CDECL napi_get_instance_data(node_api_nogc_env env,
-                                                          void** data);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_instance_data(node_api_basic_env env, void** data);
 #endif  // NAPI_VERSION >= 6
 
 #if NAPI_VERSION >= 7

package/Microsoft.ReactNative.Cxx/node-api/js_native_api_types.h

@@ -7,11 +7,6 @@
 #include <stddef.h>  // NOLINT(modernize-deprecated-headers)
 #include <stdint.h>  // NOLINT(modernize-deprecated-headers)
 
-// TODO: (vmoroz) NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT is not part of this
-// Node-API file. It is here temporary to enable compilation. Remove it after
-// updating tests.
-#define NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT
-
 #if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900)
 typedef uint16_t char16_t;
 #endif
@@ -32,7 +27,7 @@ typedef struct napi_env__* napi_env;
 // meaning that they do not affect the state of the JS engine, and can
 // therefore be called synchronously from a finalizer that itself runs
 // synchronously during GC. Such APIs can receive either a `napi_env` or a
-// `node_api_nogc_env` as their first parameter, because we should be able to
+// `node_api_basic_env` as their first parameter, because we should be able to
 // also call them during normal, non-garbage-collecting operations, whereas
 // APIs that affect the state of the JS engine can only receive a `napi_env` as
 // their first parameter, because we must not call them during GC. In lieu of
@@ -42,19 +37,21 @@ typedef struct napi_env__* napi_env;
 // expecting a non-const value.
 //
 // In conjunction with appropriate CFLAGS to warn us if we're passing a const
-// (nogc) environment into an API that expects a non-const environment, and the
-// definition of nogc finalizer function pointer types below, which receive a
-// nogc environment as their first parameter, and can thus only call nogc APIs
-// (unless the user explicitly casts the environment), we achieve the ability
-// to ensure at compile time that we do not call APIs that affect the state of
-// the JS engine from a synchronous (nogc) finalizer.
+// (basic) environment into an API that expects a non-const environment, and
+// the definition of basic finalizer function pointer types below, which
+// receive a basic environment as their first parameter, and can thus only call
+// basic APIs (unless the user explicitly casts the environment), we achieve
+// the ability to ensure at compile time that we do not call APIs that affect
+// the state of the JS engine from a synchronous (basic) finalizer.
 #if !defined(NAPI_EXPERIMENTAL) ||                                             \
     (defined(NAPI_EXPERIMENTAL) &&                                             \
-     defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT))
+     (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) ||                       \
+      defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
 typedef struct napi_env__* node_api_nogc_env;
 #else
 typedef const struct napi_env__* node_api_nogc_env;
 #endif
+typedef node_api_nogc_env node_api_basic_env;
 
 typedef struct napi_value__* napi_value;
 typedef struct napi_ref__* napi_ref;
@@ -152,13 +149,15 @@ typedef void(NAPI_CDECL* napi_finalize)(napi_env env,
 
 #if !defined(NAPI_EXPERIMENTAL) ||                                             \
     (defined(NAPI_EXPERIMENTAL) &&                                             \
-     defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT))
+     (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) ||                       \
+      defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
 typedef napi_finalize node_api_nogc_finalize;
 #else
 typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
                                                  void* finalize_data,
                                                  void* finalize_hint);
 #endif
+typedef node_api_nogc_finalize node_api_basic_finalize;
 
 typedef struct {
   // One of utf8name or name should be NULL.

package/Microsoft.ReactNative.Cxx/node-api/js_runtime_api.h

@@ -4,7 +4,7 @@
 #ifndef SRC_JS_RUNTIME_API_H_
 #define SRC_JS_RUNTIME_API_H_
 
-#include "js_native_api.h"
+#include "node_api.h"
 
 //
 // Node-API extensions required for JavaScript engine hosting.
@@ -51,6 +51,16 @@ JSR_API jsr_config_enable_gc_api(jsr_config config, bool value);
 
 JSR_API jsr_config_set_explicit_microtasks(jsr_config config, bool value);
 
+// A callback to process unhandled JS error
+typedef void(NAPI_CDECL* jsr_unhandled_error_cb)(void* cb_data,
+                                                 napi_env env,
+                                                 napi_value error);
+
+JSR_API jsr_config_on_unhandled_error(
+    jsr_config config,
+    void* cb_data,
+    jsr_unhandled_error_cb unhandled_error_cb);
+
 //=============================================================================
 // jsr_config task runner
 //=============================================================================
@@ -187,13 +197,18 @@ JSR_API jsr_get_and_clear_last_unhandled_promise_rejection(napi_env env,
                                                            napi_value* result);
 
 // Create new napi_env for the runtime.
-JSR_API jsr_create_node_api_env(napi_env root_env,
-                                int32_t api_version,
-                                napi_env* env);
+JSR_API
+jsr_create_node_api_env(napi_env root_env, int32_t api_version, napi_env* env);
 
 // Run task in the environment context.
 JSR_API jsr_run_task(napi_env env, jsr_task_run_cb task_cb, void* data);
 
+// Initializes native module.
+JSR_API jsr_initialize_native_module(napi_env env,
+                                     napi_addon_register_func register_module,
+                                     int32_t api_version,
+                                     napi_value* exports);
+
 EXTERN_C_END
 
 #endif  // !SRC_JS_RUNTIME_API_H_