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

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.h

@@ -56,8 +56,8 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
 
  private:
   void installFabricUIManager() noexcept;
-  void initiateTransaction(facebook::react::MountingCoordinator::Shared mountingCoordinator);
-  void performTransaction(facebook::react::MountingCoordinator::Shared const &mountingCoordinator);
+  void initiateTransaction(std::shared_ptr<const facebook::react::MountingCoordinator> mountingCoordinator);
+  void performTransaction(std::shared_ptr<const facebook::react::MountingCoordinator> const &mountingCoordinator);
   void RCTPerformMountInstructions(
       facebook::react::ShadowViewMutationList const &mutations,
       // facebook::react::RCTComponentViewRegistry* registry,
@@ -82,9 +82,9 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
 
   // Inherited via SchedulerDelegate
   virtual void schedulerDidFinishTransaction(
-      const facebook::react::MountingCoordinator::Shared &mountingCoordinator) override;
+      const std::shared_ptr<const facebook::react::MountingCoordinator> &mountingCoordinator) override;
   virtual void schedulerShouldRenderTransactions(
-      const facebook::react::MountingCoordinator::Shared &mountingCoordinator) override;
+      const std::shared_ptr<const facebook::react::MountingCoordinator> &mountingCoordinator) override;
   virtual void schedulerDidRequestPreliminaryViewAllocation(const facebook::react::ShadowNode &shadowView) override;
   virtual void schedulerDidDispatchCommand(
       facebook::react::ShadowView const &shadowView,

package/Microsoft.ReactNative/Fabric/ImageRequest.cpp

@@ -10,15 +10,11 @@ namespace facebook::react {
 ImageRequest::ImageRequest(
     ImageSource imageSource,
     std::shared_ptr<const ImageTelemetry> telemetry,
+    SharedFunction<> resumeFunction,
     SharedFunction<> cancelationFunction)
-    : imageSource_(std::move(imageSource)),
-      telemetry_(std::move(telemetry)),
-      cancelRequest_(std::move(cancelationFunction)) {
-  coordinator_ = std::make_shared<ImageResponseObserverCoordinator>();
-}
-
-void ImageRequest::cancel() const {
-  cancelRequest_();
+    : imageSource_(std::move(imageSource)), telemetry_(std::move(telemetry)) {
+  coordinator_ =
+      std::make_shared<ImageResponseObserverCoordinator>(std::move(resumeFunction), std::move(cancelationFunction));
 }
 
 const ImageSource &ImageRequest::getImageSource() const {

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -3,10 +3,10 @@
 
 #include "HostPlatformViewProps.h"
 
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/components/view/conversions.h>
 #include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/core/propsConversions.h>
-#include <react/utils/CoreFeatures.h>
 
 namespace facebook::react {
 
@@ -17,36 +17,37 @@ HostPlatformViewProps::HostPlatformViewProps(
     bool shouldSetRawProps)
     : BaseViewProps(context, sourceProps, rawProps),
       windowsEvents(
-          CoreFeatures::enablePropIteratorSetter ? sourceProps.windowsEvents
-                                                 : convertRawProp(context, rawProps, sourceProps.windowsEvents, {})),
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.windowsEvents
+              : convertRawProp(context, rawProps, sourceProps.windowsEvents, {})),
       enableFocusRing(
-          CoreFeatures::enablePropIteratorSetter
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.enableFocusRing
               : convertRawProp(context, rawProps, "enableFocusRing", sourceProps.enableFocusRing, true)),
       focusable(
-          CoreFeatures::enablePropIteratorSetter
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.focusable
               : convertRawProp(context, rawProps, "focusable", sourceProps.focusable, {})),
       tooltip(
-          CoreFeatures::enablePropIteratorSetter
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.tooltip
               : convertRawProp(context, rawProps, "tooltip", sourceProps.tooltip, {})),
       accessibilityPosInSet(
-          CoreFeatures::enablePropIteratorSetter
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.accessibilityPosInSet
               : convertRawProp(context, rawProps, "accessibilityPosInSet", sourceProps.accessibilityPosInSet, 0)),
       accessibilitySetSize(
-          CoreFeatures::enablePropIteratorSetter
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.accessibilitySetSize
               : convertRawProp(context, rawProps, "accessibilitySetSize", sourceProps.accessibilitySetSize, 0)),
       accessibilityLiveRegion(
-          CoreFeatures::enablePropIteratorSetter ? sourceProps.accessibilityLiveRegion
-                                                 : convertRawProp(
-                                                       context,
-                                                       rawProps,
-                                                       "accessibilityLiveRegion",
-                                                       sourceProps.accessibilityLiveRegion,
-                                                       "none")) {}
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter() ? sourceProps.accessibilityLiveRegion
+                                                                  : convertRawProp(
+                                                                        context,
+                                                                        rawProps,
+                                                                        "accessibilityLiveRegion",
+                                                                        sourceProps.accessibilityLiveRegion,
+                                                                        "none")) {}
 
 #define WINDOWS_VIEW_EVENT_CASE(eventType)                    \
   case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): {       \

package/Microsoft.ReactNative/Modules/AccessibilityInfoModule.cpp

@@ -30,6 +30,16 @@ void AccessibilityInfo::isReduceMotionEnabled(std::function<void(bool)> const &o
   });
 }
 
+void AccessibilityInfo::isInvertColorsEnabled(std::function<void(bool)> const &onSuccess) noexcept {
+  // TODO: implement ##14206
+  onSuccess(false);
+}
+
+void AccessibilityInfo::isHighTextContrastEnabled(std::function<void(bool)> const &onSuccess) noexcept {
+  // TODO: implement #14099
+  onSuccess(false);
+}
+
 void AccessibilityInfo::isTouchExplorationEnabled(std::function<void(bool)> const &onSuccess) noexcept {
   onSuccess(UiaClientsAreListening());
 }
@@ -76,6 +86,11 @@ void AccessibilityInfo::getRecommendedTimeoutMillis(
   onSuccess(mSec);
 }
 
+void AccessibilityInfo::isGrayscaleEnabled(std::function<void(bool)> const &onSuccess) noexcept {
+  // TODO: implement #14207
+  onSuccess(false);
+}
+
 void AccessibilityInfo::isAccessibilityServiceEnabled(std::function<void(bool)> const &onSuccess) noexcept {
   onSuccess(false);
 }

package/Microsoft.ReactNative/Modules/AccessibilityInfoModule.h

@@ -17,6 +17,12 @@ struct AccessibilityInfo : public std::enable_shared_from_this<AccessibilityInfo
   REACT_METHOD(isReduceMotionEnabled)
   void isReduceMotionEnabled(std::function<void(bool)> const &onSuccess) noexcept;
 
+  REACT_METHOD(isInvertColorsEnabled)
+  void isInvertColorsEnabled(std::function<void(bool)> const &onSuccess) noexcept;
+
+  REACT_METHOD(isHighTextContrastEnabled)
+  void isHighTextContrastEnabled(std::function<void(bool)> const &onSuccess) noexcept;
+
   REACT_METHOD(isTouchExplorationEnabled)
   void isTouchExplorationEnabled(std::function<void(bool)> const &onSuccess) noexcept;
 
@@ -29,6 +35,9 @@ struct AccessibilityInfo : public std::enable_shared_from_this<AccessibilityInfo
   REACT_METHOD(getRecommendedTimeoutMillis)
   void getRecommendedTimeoutMillis(double mSec, std::function<void(double)> const &onSuccess) noexcept;
 
+  REACT_METHOD(isGrayscaleEnabled)
+  void isGrayscaleEnabled(std::function<void(bool)> const &onSuccess) noexcept;
+
   REACT_METHOD(isAccessibilityServiceEnabled)
   void isAccessibilityServiceEnabled(std::function<void(bool)> const &onSuccess) noexcept;
 

package/Microsoft.ReactNative/ReactHost/ReactHost.cpp

@@ -6,6 +6,9 @@
 #include <ReactPropertyBag.h>
 #include <winrt/Windows.Foundation.h>
 
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+
 namespace Mso::React {
 
 //=============================================================================================
@@ -277,6 +280,18 @@ bool ReactOptions::EnableDefaultCrashHandler() const noexcept {
   return winrt::unbox_value_or<bool>(properties.Get(EnableDefaultCrashHandlerProperty()), false);
 }
 
+class ReactNativeWindowsFeatureFlags : public facebook::react::ReactNativeFeatureFlagsDefaults {
+ public:
+  bool disableEventLoopOnBridgeless() override {
+    return true; // Disable event loop until we are on a JSI version that supports microtasks
+  }
+
+  bool enableCppPropsIteratorSetter() override {
+    return true;
+  }
+};
+
+std::once_flag g_FlagInitFeatureFlags;
 //=============================================================================================
 // ReactHost implementation
 //=============================================================================================
@@ -284,7 +299,11 @@ bool ReactOptions::EnableDefaultCrashHandler() const noexcept {
 ReactHost::ReactHost(Mso::DispatchQueue const &queue) noexcept
     : Super{EnsureSerialQueue(queue)},
       m_options{Queue(), m_mutex},
-      m_notifyWhenClosed{ReactHostRegistry::Register(*this), Queue(), m_mutex} {}
+      m_notifyWhenClosed{ReactHostRegistry::Register(*this), Queue(), m_mutex} {
+  std::call_once(g_FlagInitFeatureFlags, []() noexcept {
+    facebook::react::ReactNativeFeatureFlags::override(std::make_unique<ReactNativeWindowsFeatureFlags>());
+  });
+}
 
 ReactHost::~ReactHost() noexcept {}
 

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -641,8 +641,10 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
               auto timerManager = std::make_shared<facebook::react::TimerManager>(std::move(timerRegistry));
               timerRegistryRaw->setTimerManager(timerManager);
 
-              auto jsErrorHandlingFunc = [this](const facebook::react::JsErrorHandler::ParsedError &error) noexcept {
-                OnJSError(std::move(error));
+              auto jsErrorHandlingFunc = [this](
+                                             facebook::jsi::Runtime &runtime,
+                                             const facebook::react::JsErrorHandler::ParsedError &error) noexcept {
+                OnJSError(runtime, std::move(error));
               };
 
               if (devSettings->useDirectDebugger) {
@@ -1263,16 +1265,19 @@ void ReactInstanceWin::OnError(const Mso::ErrorCode &errorCode) noexcept {
 }
 
 #ifdef USE_FABRIC
-void ReactInstanceWin::OnJSError(const facebook::react::JsErrorHandler::ParsedError &error) noexcept {
+void ReactInstanceWin::OnJSError(
+    facebook::jsi::Runtime &runtime,
+    const facebook::react::JsErrorHandler::ParsedError &error) noexcept {
   ErrorInfo errorInfo;
   errorInfo.Message = error.message;
   auto errorCode = Mso::React::ReactErrorProvider().MakeErrorCode(Mso::React::ReactError{errorInfo.Message.c_str()});
 
-  for (const facebook::react::JsErrorHandler::ParsedError::StackFrame &frame : error.frames) {
-    errorInfo.Callstack.push_back({frame.fileName, frame.methodName, frame.lineNumber, frame.columnNumber});
+  for (const facebook::react::JsErrorHandler::ParsedError::StackFrame &frame : error.stack) {
+    errorInfo.Callstack.push_back(
+        {frame.file.value(), frame.methodName, frame.lineNumber.value(), frame.column.value()});
   }
 
-  errorInfo.Id = error.exceptionId;
+  errorInfo.Id = error.id;
 
   bool isFatal = error.isFatal;
 

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -141,7 +141,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   void OnError(const Mso::ErrorCode &errorcode) noexcept;
   void OnErrorWithMessage(const std::string &errorMessage) noexcept;
 #ifdef USE_FABRIC
-  void OnJSError(const facebook::react::JsErrorHandler::ParsedError &error) noexcept;
+  void OnJSError(facebook::jsi::Runtime &runtime, const facebook::react::JsErrorHandler::ParsedError &error) noexcept;
 #endif
   void OnLiveReload() noexcept;
   void OnWaitingForDebugger() noexcept;

package/Microsoft.ReactNative/SynchronousEventBeat.cpp

@@ -6,17 +6,27 @@
 namespace Microsoft::ReactNative {
 
 SynchronousEventBeat::SynchronousEventBeat(
-    facebook::react::EventBeat::SharedOwnerBox const &ownerBox,
+    std::shared_ptr<facebook::react::EventBeat::OwnerBox> const ownerBox,
     const winrt::Microsoft::ReactNative::ReactContext &context,
     facebook::react::RuntimeExecutor runtimeExecutor,
     std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler)
-    : EventBeat(ownerBox),
+    : EventBeat(ownerBox, *runtimeScheduler),
       m_context(context),
       m_runtimeExecutor(runtimeExecutor),
       m_runtimeScheduler(std::move(runtimeScheduler)) {}
 
+void SynchronousEventBeat::beat(facebook::jsi::Runtime &runtime) const {
+  if (!this->isEventBeatRequested_) {
+    return;
+  }
+  isEventBeatRequested_ = false;
+  if (beatCallback_) {
+    beatCallback_(runtime);
+  }
+}
+
 void SynchronousEventBeat::induce() const {
-  if (!isRequested_) {
+  if (!isEventBeatRequested_) {
     return;
   }
 
@@ -26,7 +36,7 @@ void SynchronousEventBeat::induce() const {
 }
 
 void SynchronousEventBeat::lockExecutorAndBeat() const {
-  if (!this->isRequested_) {
+  if (!this->isEventBeatRequested_) {
     return;
   }
 

package/Microsoft.ReactNative/SynchronousEventBeat.h

@@ -11,12 +11,14 @@ namespace Microsoft::ReactNative {
 class SynchronousEventBeat final : public facebook::react::EventBeat {
  public:
   SynchronousEventBeat(
-      facebook::react::EventBeat::SharedOwnerBox const &ownerBox,
+      std::shared_ptr<facebook::react::EventBeat::OwnerBox> const ownerBox,
       const winrt::Microsoft::ReactNative::ReactContext &context,
       facebook::react::RuntimeExecutor runtimeExecutor,
       std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler);
 
-  void induce() const override;
+  void beat(facebook::jsi::Runtime &runtime) const;
+
+  void induce() const;
 
   void lockExecutorAndBeat() const;
 

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

@@ -0,0 +1,78 @@
+// 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_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,48 @@
+// 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_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_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_