react-native-windows 0.80.5 → 0.80.6

package/Microsoft.ReactNative.Cxx/ApiLoaders/JSRuntimeApi.cpp

@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "JSRuntimeApi.h"
+
+EXTERN_C_START
+
+// Default JSR function implementations if they are not found in the engine DLL.
+extern napi_status NAPI_CDECL default_jsr_open_napi_env_scope(napi_env env, jsr_napi_env_scope *scope);
+extern napi_status NAPI_CDECL default_jsr_close_napi_env_scope(napi_env env, jsr_napi_env_scope scope);
+extern napi_status NAPI_CDECL default_jsr_get_description(napi_env env, const char **result);
+extern napi_status NAPI_CDECL default_jsr_queue_microtask(napi_env env, napi_value callback);
+extern napi_status NAPI_CDECL default_jsr_drain_microtasks(napi_env env, int32_t max_count_hint, bool *result);
+extern napi_status NAPI_CDECL default_jsr_is_inspectable(napi_env env, bool *result);
+
+extern napi_status NAPI_CDECL default_jsr_create_prepared_script(
+    napi_env env,
+    const uint8_t *script_utf8,
+    size_t script_length,
+    jsr_data_delete_cb script_delete_cb,
+    void *deleter_data,
+    const char *source_url,
+    jsr_prepared_script *result);
+extern napi_status NAPI_CDECL default_jsr_delete_prepared_script(napi_env env, jsr_prepared_script prepared_script);
+extern napi_status NAPI_CDECL
+default_jsr_prepared_script_run(napi_env env, jsr_prepared_script prepared_script, napi_value *result);
+
+EXTERN_C_END
+
+namespace Microsoft::NodeApiJsi {
+
+namespace {
+
+struct JSRuntimeApiNames {
+#define JSR_FUNC(func) static constexpr const char func[] = #func;
+#define JSR_JSI_FUNC JSR_FUNC
+#define JSR_PREPARED_SCRIPT JSR_FUNC
+#include "JSRuntimeApi.inc"
+};
+
+// Prepared script functions either should be all loaded or we use all default functions.
+void loadPreparedScriptFuncs() {
+  JSRuntimeApi *current = JSRuntimeApi::current();
+  bool useDefault = false;
+#define JSR_PREPARED_SCRIPT(func)                                                         \
+  decltype(::func) *loaded_##func =                                                       \
+      reinterpret_cast<decltype(::func) *>(current->getFuncPtr(JSRuntimeApiNames::func)); \
+  useDefault = useDefault || loaded_##func == nullptr;
+#include "JSRuntimeApi.inc"
+#define JSR_PREPARED_SCRIPT(func)                                                             \
+  size_t offset_##func = offsetof(JSRuntimeApi, func);                                        \
+  *reinterpret_cast<decltype(::func) **>(reinterpret_cast<char *>(current) + offset_##func) = \
+      useDefault ? &default_##func : loaded_##func;
+#include "JSRuntimeApi.inc"
+}
+
+} // namespace
+
+thread_local JSRuntimeApi *JSRuntimeApi::current_{};
+
+JSRuntimeApi::JSRuntimeApi(IFuncResolver *funcResolver)
+    : NodeApi(funcResolver)
+#define JSR_FUNC(func)                                                                                                 \
+  ,                                                                                                                    \
+      func(&ApiFuncResolver<JSRuntimeApi, decltype(::func) *, JSRuntimeApiNames::func, offsetof(JSRuntimeApi, func)>:: \
+               stub)
+#define JSR_JSI_FUNC(func)                                                                                             \
+  ,                                                                                                                    \
+      func(&ApiFuncResolver<JSRuntimeApi, decltype(::func) *, JSRuntimeApiNames::func, offsetof(JSRuntimeApi, func)>:: \
+               optionalStub<&default_##func>)
+#define JSR_PREPARED_SCRIPT(func)                                                                                      \
+  ,                                                                                                                    \
+      func(&ApiFuncResolver<JSRuntimeApi, decltype(::func) *, JSRuntimeApiNames::func, offsetof(JSRuntimeApi, func)>:: \
+               preloadStub<&loadPreparedScriptFuncs>)
+#include "JSRuntimeApi.inc"
+{
+}
+
+} // namespace Microsoft::NodeApiJsi

package/Microsoft.ReactNative.Cxx/ApiLoaders/JSRuntimeApi.h

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#ifndef APILOADERS_JSRUNTIMEAPI_H_
+#define APILOADERS_JSRUNTIMEAPI_H_
+
+#include <js_runtime_api.h>
+#include "NodeApi.h"
+
+namespace Microsoft::NodeApiJsi {
+
+class JSRuntimeApi : public NodeApi {
+ public:
+  JSRuntimeApi(IFuncResolver *funcResolver);
+
+  static JSRuntimeApi *current() {
+    return current_;
+  }
+
+  static void setCurrent(JSRuntimeApi *current) {
+    NodeApi::setCurrent(current);
+    current_ = current;
+  }
+
+  class Scope : public NodeApi::Scope {
+   public:
+    Scope(JSRuntimeApi *api) : NodeApi::Scope(api), prevJSRuntimeApi_(JSRuntimeApi::current_) {
+      JSRuntimeApi::current_ = api;
+    }
+
+    ~Scope() {
+      JSRuntimeApi::current_ = prevJSRuntimeApi_;
+    }
+
+   private:
+    JSRuntimeApi *prevJSRuntimeApi_;
+  };
+
+ public:
+#define JSR_FUNC(func) decltype(::func) *const func;
+#define JSR_JSI_FUNC JSR_FUNC
+#define JSR_PREPARED_SCRIPT JSR_FUNC
+#include "JSRuntimeApi.inc"
+
+ private:
+  static thread_local JSRuntimeApi *current_;
+};
+
+} // namespace Microsoft::NodeApiJsi
+
+#endif // !APILOADERS_JSRUNTIMEAPI_H_

package/Microsoft.ReactNative.Cxx/ApiLoaders/JSRuntimeApi.inc

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#ifndef JSR_FUNC
+#define JSR_FUNC(func)
+#endif
+
+#ifndef JSR_JSI_FUNC
+#define JSR_JSI_FUNC(func)
+#endif
+
+#ifndef JSR_PREPARED_SCRIPT
+#define JSR_PREPARED_SCRIPT(func)
+#endif
+
+// The JS runtime functions sorted alphabetically.
+JSR_FUNC(jsr_collect_garbage)
+JSR_FUNC(jsr_config_enable_gc_api)
+JSR_FUNC(jsr_config_enable_inspector)
+JSR_FUNC(jsr_config_set_explicit_microtasks)
+JSR_FUNC(jsr_config_set_inspector_break_on_start)
+JSR_FUNC(jsr_config_set_inspector_port)
+JSR_FUNC(jsr_config_set_inspector_runtime_name)
+JSR_FUNC(jsr_config_set_script_cache)
+JSR_FUNC(jsr_config_set_task_runner)
+JSR_FUNC(jsr_create_config)
+JSR_FUNC(jsr_create_runtime)
+JSR_FUNC(jsr_delete_config)
+JSR_FUNC(jsr_delete_runtime)
+JSR_FUNC(jsr_get_and_clear_last_unhandled_promise_rejection)
+JSR_FUNC(jsr_has_unhandled_promise_rejection)
+JSR_FUNC(jsr_run_script)
+JSR_FUNC(jsr_runtime_get_node_api_env)
+
+// The JS runtime functions needed for JSI.
+JSR_JSI_FUNC(jsr_close_napi_env_scope)
+JSR_JSI_FUNC(jsr_queue_microtask)
+JSR_JSI_FUNC(jsr_drain_microtasks)
+JSR_JSI_FUNC(jsr_get_description)
+JSR_JSI_FUNC(jsr_is_inspectable)
+JSR_JSI_FUNC(jsr_open_napi_env_scope)
+
+// The JS runtime functions needed for prepared script.
+JSR_PREPARED_SCRIPT(jsr_create_prepared_script)
+JSR_PREPARED_SCRIPT(jsr_delete_prepared_script)
+JSR_PREPARED_SCRIPT(jsr_prepared_script_run)
+
+#undef JSR_FUNC
+#undef JSR_JSI_FUNC
+#undef JSR_PREPARED_SCRIPT

package/Microsoft.ReactNative.Cxx/ApiLoaders/NodeApi.cpp

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "NodeApi.h"
+
+namespace Microsoft::NodeApiJsi {
+
+namespace {
+
+struct NodeApiNames {
+#define NODE_API_FUNC(func) static constexpr const char func[] = #func;
+#include "NodeApi.inc"
+};
+
+} // namespace
+
+LibFuncResolver::LibFuncResolver(const char *libName) : libHandle_(LibLoader::loadLib(libName)) {}
+
+FuncPtr LibFuncResolver::getFuncPtr(const char *funcName) {
+  return LibLoader::getFuncPtr(libHandle_, funcName);
+}
+
+DelayLoadedApi::DelayLoadedApi(IFuncResolver *funcResolver) : funcResolver_(funcResolver) {}
+
+DelayLoadedApi::~DelayLoadedApi() = default;
+
+FuncPtr DelayLoadedApi::getFuncPtr(const char *funcName) {
+  return funcResolver_->getFuncPtr(funcName);
+}
+
+thread_local NodeApi *NodeApi::current_{};
+
+NodeApi::NodeApi(IFuncResolver *funcResolver)
+    : DelayLoadedApi(funcResolver)
+#define NODE_API_FUNC(func) \
+  , func(&ApiFuncResolver<NodeApi, decltype(::func) *, NodeApiNames::func, offsetof(NodeApi, func)>::stub)
+#include "NodeApi.inc"
+{
+}
+
+} // namespace Microsoft::NodeApiJsi

package/Microsoft.ReactNative.Cxx/ApiLoaders/NodeApi.h

@@ -0,0 +1,127 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+#ifndef APILOADERS_NODEAPI_H_
+#define APILOADERS_NODEAPI_H_
+
+#include <js_native_api.h>
+
+namespace Microsoft::NodeApiJsi {
+
+using LibHandle = struct LibHandle_t *;
+using FuncPtr = struct FuncPtr_t *;
+
+class LibLoader {
+ public:
+  static LibHandle loadLib(const char *libName);
+  static FuncPtr getFuncPtr(LibHandle libHandle, const char *funcName);
+};
+
+template <typename TApi, typename T, const char *funcName, size_t offset>
+struct ApiFuncResolver;
+
+template <typename TApi, typename TResult, const char *funcName, size_t offset, typename... TArgs>
+struct ApiFuncResolver<TApi, TResult(NAPI_CDECL *)(TArgs...), funcName, offset> {
+  // Stub is a special function that loads the targeting function on the first call,
+  // replaces function pointer field with the loaded function, and executes the function.
+  // After this all future calls to the loaded function are going to be directly from
+  // the field and not use this Stub.
+  static TResult NAPI_CDECL stub(TArgs... args) {
+    using TFunc = TResult(NAPI_CDECL *)(TArgs...);
+    TApi *current = TApi::current();
+    TFunc func = reinterpret_cast<TFunc>(current->getFuncPtr(funcName));
+    *reinterpret_cast<TFunc *>(reinterpret_cast<char *>(current) + offset) = func;
+    return (*func)(args...);
+  }
+
+  // Optional stub tries to load target function on the first call and set it
+  // as the function pointer. If loading fails, then it uses provided default
+  // function implementation. The default function can either do the required
+  // work or return a failure.
+  template <TResult(NAPI_CDECL *defaultFunc)(TArgs...)>
+  static TResult NAPI_CDECL optionalStub(TArgs... args) {
+    using TFunc = TResult(NAPI_CDECL *)(TArgs...);
+    TApi *current = TApi::current();
+    TFunc func = reinterpret_cast<TFunc>(current->getFuncPtr(funcName));
+    if (func == nullptr) {
+      func = defaultFunc;
+    }
+    *reinterpret_cast<TFunc *>(reinterpret_cast<char *>(current) + offset) = func;
+    return (*func)(args...);
+  }
+
+  template <void (*preloadFunc)()>
+  static TResult NAPI_CDECL preloadStub(TArgs... args) {
+    using TFunc = TResult(NAPI_CDECL *)(TArgs...);
+    preloadFunc();
+    TApi *current = TApi::current();
+    TFunc func = *reinterpret_cast<TFunc *>(reinterpret_cast<char *>(current) + offset);
+    return (*func)(args...);
+  }
+};
+
+struct IFuncResolver {
+  virtual FuncPtr getFuncPtr(const char *funcName) = 0;
+};
+
+class LibFuncResolver : public IFuncResolver {
+ public:
+  LibFuncResolver(const char *libName);
+  FuncPtr getFuncPtr(const char *funcName) override;
+
+ private:
+  LibHandle libHandle_;
+};
+
+class DelayLoadedApi {
+ public:
+  DelayLoadedApi(IFuncResolver *funcResolver);
+  ~DelayLoadedApi();
+
+  FuncPtr getFuncPtr(const char *funcName);
+
+  DelayLoadedApi(const DelayLoadedApi &) = delete;
+  DelayLoadedApi &operator=(const DelayLoadedApi &) = delete;
+
+ private:
+  IFuncResolver *funcResolver_;
+};
+
+class NodeApi : public DelayLoadedApi {
+ public:
+  NodeApi(IFuncResolver *funcResolver);
+
+  static NodeApi *current() {
+    return current_;
+  }
+
+  static void setCurrent(NodeApi *current) {
+    current_ = current;
+  }
+
+  class Scope {
+   public:
+    Scope(NodeApi *nodeApi) : prevNodeApi_(NodeApi::current_) {
+      NodeApi::current_ = nodeApi;
+    }
+
+    ~Scope() {
+      NodeApi::current_ = prevNodeApi_;
+    }
+
+   private:
+    NodeApi *prevNodeApi_;
+  };
+
+ public:
+#define NODE_API_FUNC(func) decltype(::func) *const func;
+#include "NodeApi.inc"
+
+ private:
+  static thread_local NodeApi *current_;
+};
+
+} // namespace Microsoft::NodeApiJsi
+
+#endif // !APILOADERS_NODEAPI_H_

package/Microsoft.ReactNative.Cxx/ApiLoaders/NodeApi.inc

@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#ifndef NODE_API_FUNC
+#define NODE_API_FUNC(func)
+#endif
+
+// The Node-API functions sorted alphabetically.
+NODE_API_FUNC(napi_add_finalizer)
+NODE_API_FUNC(napi_adjust_external_memory)
+NODE_API_FUNC(napi_call_function)
+NODE_API_FUNC(napi_check_object_type_tag)
+NODE_API_FUNC(napi_close_escapable_handle_scope)
+NODE_API_FUNC(napi_close_handle_scope)
+NODE_API_FUNC(napi_coerce_to_bool)
+NODE_API_FUNC(napi_coerce_to_number)
+NODE_API_FUNC(napi_coerce_to_object)
+NODE_API_FUNC(napi_coerce_to_string)
+NODE_API_FUNC(napi_create_array_with_length)
+NODE_API_FUNC(napi_create_array)
+NODE_API_FUNC(napi_create_arraybuffer)
+NODE_API_FUNC(napi_create_bigint_int64)
+NODE_API_FUNC(napi_create_bigint_uint64)
+NODE_API_FUNC(napi_create_bigint_words)
+NODE_API_FUNC(napi_create_dataview)
+NODE_API_FUNC(napi_create_date)
+NODE_API_FUNC(napi_create_double)
+NODE_API_FUNC(napi_create_error)
+NODE_API_FUNC(napi_create_external_arraybuffer)
+NODE_API_FUNC(napi_create_external)
+NODE_API_FUNC(napi_create_function)
+NODE_API_FUNC(napi_create_int32)
+NODE_API_FUNC(napi_create_int64)
+NODE_API_FUNC(napi_create_object)
+NODE_API_FUNC(napi_create_promise)
+NODE_API_FUNC(napi_create_range_error)
+NODE_API_FUNC(napi_create_reference)
+NODE_API_FUNC(napi_create_string_latin1)
+NODE_API_FUNC(napi_create_string_utf16)
+NODE_API_FUNC(napi_create_string_utf8)
+NODE_API_FUNC(napi_create_symbol)
+NODE_API_FUNC(napi_create_type_error)
+NODE_API_FUNC(napi_create_typedarray)
+NODE_API_FUNC(napi_create_uint32)
+NODE_API_FUNC(napi_define_class)
+NODE_API_FUNC(napi_define_properties)
+NODE_API_FUNC(napi_delete_element)
+NODE_API_FUNC(napi_delete_property)
+NODE_API_FUNC(napi_delete_reference)
+NODE_API_FUNC(napi_detach_arraybuffer)
+NODE_API_FUNC(napi_escape_handle)
+NODE_API_FUNC(napi_get_all_property_names)
+NODE_API_FUNC(napi_get_and_clear_last_exception)
+NODE_API_FUNC(napi_get_array_length)
+NODE_API_FUNC(napi_get_arraybuffer_info)
+NODE_API_FUNC(napi_get_boolean)
+NODE_API_FUNC(napi_get_cb_info)
+NODE_API_FUNC(napi_get_dataview_info)
+NODE_API_FUNC(napi_get_date_value)
+NODE_API_FUNC(napi_get_element)
+NODE_API_FUNC(napi_get_global)
+NODE_API_FUNC(napi_get_instance_data)
+NODE_API_FUNC(napi_get_last_error_info)
+NODE_API_FUNC(napi_get_named_property)
+NODE_API_FUNC(napi_get_new_target)
+NODE_API_FUNC(napi_get_null)
+NODE_API_FUNC(napi_get_property_names)
+NODE_API_FUNC(napi_get_property)
+NODE_API_FUNC(napi_get_prototype)
+NODE_API_FUNC(napi_get_reference_value)
+NODE_API_FUNC(napi_get_typedarray_info)
+NODE_API_FUNC(napi_get_undefined)
+NODE_API_FUNC(napi_get_value_bigint_int64)
+NODE_API_FUNC(napi_get_value_bigint_uint64)
+NODE_API_FUNC(napi_get_value_bigint_words)
+NODE_API_FUNC(napi_get_value_bool)
+NODE_API_FUNC(napi_get_value_double)
+NODE_API_FUNC(napi_get_value_external)
+NODE_API_FUNC(napi_get_value_int32)
+NODE_API_FUNC(napi_get_value_int64)
+NODE_API_FUNC(napi_get_value_string_latin1)
+NODE_API_FUNC(napi_get_value_string_utf16)
+NODE_API_FUNC(napi_get_value_string_utf8)
+NODE_API_FUNC(napi_get_value_uint32)
+NODE_API_FUNC(napi_get_version)
+NODE_API_FUNC(napi_has_element)
+NODE_API_FUNC(napi_has_named_property)
+NODE_API_FUNC(napi_has_own_property)
+NODE_API_FUNC(napi_has_property)
+NODE_API_FUNC(napi_instanceof)
+NODE_API_FUNC(napi_is_array)
+NODE_API_FUNC(napi_is_arraybuffer)
+NODE_API_FUNC(napi_is_dataview)
+NODE_API_FUNC(napi_is_date)
+NODE_API_FUNC(napi_is_detached_arraybuffer)
+NODE_API_FUNC(napi_is_error)
+NODE_API_FUNC(napi_is_exception_pending)
+NODE_API_FUNC(napi_is_promise)
+NODE_API_FUNC(napi_is_typedarray)
+NODE_API_FUNC(napi_new_instance)
+NODE_API_FUNC(napi_object_freeze)
+NODE_API_FUNC(napi_object_seal)
+NODE_API_FUNC(napi_open_escapable_handle_scope)
+NODE_API_FUNC(napi_open_handle_scope)
+NODE_API_FUNC(napi_reference_ref)
+NODE_API_FUNC(napi_reference_unref)
+NODE_API_FUNC(napi_reject_deferred)
+NODE_API_FUNC(napi_remove_wrap)
+NODE_API_FUNC(napi_resolve_deferred)
+NODE_API_FUNC(napi_run_script)
+NODE_API_FUNC(napi_set_element)
+NODE_API_FUNC(napi_set_instance_data)
+NODE_API_FUNC(napi_set_named_property)
+NODE_API_FUNC(napi_set_property)
+NODE_API_FUNC(napi_strict_equals)
+NODE_API_FUNC(napi_throw_error)
+NODE_API_FUNC(napi_throw_range_error)
+NODE_API_FUNC(napi_throw_type_error)
+NODE_API_FUNC(napi_throw)
+NODE_API_FUNC(napi_type_tag_object)
+NODE_API_FUNC(napi_typeof)
+NODE_API_FUNC(napi_unwrap)
+NODE_API_FUNC(napi_wrap)
+
+#undef NODE_API_FUNC

package/Microsoft.ReactNative.Cxx/ApiLoaders/NodeApi_posix.cpp

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "NodeApi.h"
+
+namespace Microsoft::NodeApiJsi {
+
+LibHandle LibLoader::loadLib(const char *libName) {
+  // TODO: implement
+}
+
+FuncPtr LibLoader::getFuncPtr(LibHandle libHandle, const char *funcName) {
+  // TODO: implement
+}
+
+} // namespace Microsoft::NodeApiJsi

package/Microsoft.ReactNative.Cxx/ApiLoaders/NodeApi_win.cpp

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "NodeApi.h"
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+
+namespace Microsoft::NodeApiJsi {
+
+LibHandle LibLoader::loadLib(const char *libName) {
+  return reinterpret_cast<LibHandle>(LoadLibraryA(libName));
+}
+
+FuncPtr LibLoader::getFuncPtr(LibHandle libHandle, const char *funcName) {
+  return reinterpret_cast<FuncPtr>(GetProcAddress(reinterpret_cast<HMODULE>(libHandle), funcName));
+}
+
+} // namespace Microsoft::NodeApiJsi