react-native-windows 0.0.0-canary.95 → 0.0.0-canary.950

package/Microsoft.ReactNative.Cxx/NativeModules.h

@@ -1,9 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+// IMPORTANT: Before updating this file
+// please read react-native-windows repo:
+// vnext/Microsoft.ReactNative.Cxx/README.md
 
 #pragma once
-#include "winrt/Microsoft.ReactNative.h"
-
+#include <winrt/Microsoft.ReactNative.h>
+#include <winrt/Windows.Foundation.h>
 #include "JSValueReader.h"
 #include "JSValueWriter.h"
 #include "ModuleRegistration.h"
@@ -24,15 +27,41 @@
 // REACT_MODULE annotates a C++ struct as a ReactNative module.
 // It can be any struct which can be instantiated using a default constructor.
 // Note that it must be a 'struct', not 'class' because macro does a forward declaration using the 'struct' keyword.
+//
+// REACT_EVENTs within a REACT_MODULE will trigger an event on a global event emitter, such as RCTDeviceEventEmitter.
+// To use the newer EventEmitters exposed directly on this module, use REACT_TURBO_MODULE instead.
 #define REACT_MODULE(/* moduleStruct, [opt] moduleName, [opt] eventEmitterName */...) \
   INTERNAL_REACT_MODULE(__VA_ARGS__)(__VA_ARGS__)
 
+// REACT_TURBO_MODULE(moduleStruct, [opt] moduleName)
+// Arguments:
+// - moduleStruct (required) - the struct name the macro is attached to.
+// - moduleName (optional) - the module name visible to JavaScript. Default is the moduleStruct name.
+//
+// REACT_TURBO_MODULE annotates a C++ struct as a ReactNative module.
+// It can be any struct which can be instantiated using a default constructor.
+// Note that it must be a 'struct', not 'class' because macro does a forward declaration using the 'struct' keyword.
+//
+// REACT_EVENTs within a REACT_TURBO_MODULE will return a JS EventEmitter directly from the module.
+#define REACT_TURBO_MODULE(/* moduleStruct, [opt] moduleName */...) \
+  INTERNAL_REACT_TURBO_MODULE(__VA_ARGS__)(__VA_ARGS__)
+
+// REACT_MODULE_NOREG is REACT_MODULE without auto registration
+// they have the same arguments
+#define REACT_MODULE_NOREG(/* moduleStruct, [opt] moduleName, [opt] eventEmitterName */...) \
+  INTERNAL_REACT_MODULE_NOREG(__VA_ARGS__)(__VA_ARGS__)
+
+// REACT_TURBO_MODULE_NOREG is REACT_TURBO_MODULE without auto registration
+// they have the same arguments
+#define REACT_TURBO_MODULE_NOREG(/* moduleStruct, [opt] moduleName */...) \
+  INTERNAL_REACT_TURBO_MODULE_NOREG(__VA_ARGS__)(__VA_ARGS__)
+
 // REACT_INIT(method)
 // Arguments:
 // - method (required) - the method name the macro is attached to.
 //
 // REACT_INIT annotates a method that is called when a native module is initialized.
-// It must have 'IReactContext const &' parameter.
+// It must have 'ReactContext const &' parameter.
 // It must be an instance method.
 #define REACT_INIT(method) INTERNAL_REACT_MEMBER_2_ARGS(InitMethod, method)
 
@@ -72,6 +101,16 @@
 // It can be an instance or static method.
 #define REACT_CONSTANT_PROVIDER(method) INTERNAL_REACT_MEMBER_2_ARGS(ConstantMethod, method)
 
+// REACT_GET_CONSTANTS(method)
+// Arguments:
+// - method (required) - the method name the macro is attached to.
+//
+// REACT_GET_CONSTANTS annotates a method that defines constants.
+// It must have no parameter.
+// It must return a REACT_STRUCT decorated struct, fields become constants.
+// It can be an instance or static method.
+#define REACT_GET_CONSTANTS(method) INTERNAL_REACT_MEMBER_2_ARGS(ConstantStrongTypedMethod, method)
+
 // REACT_CONSTANT(field, [opt] constantName)
 // Arguments:
 // - field (required) - the field name the macro is attached to.
@@ -108,6 +147,11 @@
 #define REACT_FUNCTION(/* field, [opt] functionName, [opt] moduleName */...) \
   INTERNAL_REACT_MEMBER(__VA_ARGS__)(FunctionField, __VA_ARGS__)
 
+#define REACT_SHOW_CONSTANT_SIGNATURES(signatures)  \
+  " (see details below in output).\n"               \
+  "  It must be one of the following:\n" signatures \
+  "  The C++ method name could be different, just keep the method name identical to the argument in REACT_GET_CONSTANTS\n"
+
 #define REACT_SHOW_METHOD_SIGNATURES(methodName, signatures)                      \
   " (see details below in output).\n"                                             \
   "  It must be one of the following:\n" signatures                               \
@@ -122,6 +166,19 @@
   "\" to the attribute:\n"                                                        \
   "    REACT_SYNC_METHOD(method, L\"" methodName "\")\n...\n"
 
+#define REACT_SHOW_EVENT_SIGNATURES(eventName, signatures)                       \
+  " (see details below in output).\n"                                            \
+  "  It must be one of the following:\n" signatures                              \
+  "  The C++ member name could be different. In that case add the L\"" eventName \
+  "\" to the attribute:\n"                                                       \
+  "    REACT_EVENT(member, L\"" eventName "\")\n...\n"
+
+#define REACT_SHOW_CONSTANT_SPEC_ERRORS(index, typeName, signatures)                                        \
+  static_assert(                                                                                            \
+      constantCheckResults[index].IsMethodFound,                                                            \
+      "Method for constant type '" typeName "' is not defined" REACT_SHOW_CONSTANT_SIGNATURES(signatures)); \
+  static_assert(constantCheckResults[index].IsMethodUnique, "Method for constant type '" typeName "' is not unique");
+
 #define REACT_SHOW_METHOD_SPEC_ERRORS(index, methodName, signatures)                                        \
   static_assert(methodCheckResults[index].IsUniqueName, "Name '" methodName "' used for multiple methods"); \
   static_assert(                                                                                            \
@@ -140,8 +197,20 @@
       methodCheckResults[index].IsSignatureMatching,                                                        \
       "Method '" methodName "' does not match signature" REACT_SHOW_SYNC_METHOD_SIGNATURES(methodName, signatures));
 
+#define REACT_SHOW_EVENTEMITTER_SPEC_ERRORS(index, methodName, signatures)                                 \
+  static_assert(                                                                                           \
+      methodCheckResults[index].IsTurboModule,                                                             \
+      "EventEmitter '" methodName                                                                          \
+      "' requires that the module be a TurboModule.  Use REACT_TURBO_MODULE rather than REACT_MODULE");    \
+  static_assert(                                                                                           \
+      methodCheckResults[index].IsMethodFound,                                                             \
+      "EventEmitter '" methodName "' is not defined" REACT_SHOW_EVENT_SIGNATURES(methodName, signatures)); \
+  static_assert(                                                                                           \
+      methodCheckResults[index].IsSignatureMatching,                                                       \
+      "EventEmitter '" methodName "' does not match signature" REACT_SHOW_EVENT_SIGNATURES(methodName, signatures));
+
 //
-// Code below helps to register React native modules and verify method signatures
+// Code below helps to register React Native modules and verify method signatures
 // against specification.
 //
 
@@ -211,7 +280,7 @@ struct CallbackCreator<TCallback<void(TArgs...)>> {
   static TCallback<void(TArgs...)> Create(
       IJSValueWriter const &argWriter,
       MethodResultCallback const &callback) noexcept {
-    return TCallback([ callback, argWriter ](TArgs... args) noexcept {
+    return TCallback<void(TArgs...)>([callback, argWriter](TArgs... args) noexcept {
       WriteArgs(argWriter, std::move(args)...);
       callback(argWriter);
     });
@@ -224,7 +293,7 @@ struct CallbackCreator<TCallback<void(TArgs...) noexcept>> {
   static TCallback<void(TArgs...)> Create(
       IJSValueWriter const &argWriter,
       MethodResultCallback const &callback) noexcept {
-    return TCallback([ callback, argWriter ](TArgs... args) noexcept {
+    return TCallback<void(TArgs...)>([callback, argWriter](TArgs... args) noexcept {
       WriteArgs(argWriter, std::move(args)...);
       callback(argWriter);
     });
@@ -256,7 +325,7 @@ struct IsPromise<ReactPromise<T>> : std::true_type {};
 template <class TArgsTuple>
 constexpr size_t GetPromiseCount() noexcept {
   if constexpr (
-      std::tuple_size_v<TArgsTuple>> 0 &&
+      std::tuple_size_v < TArgsTuple >> 0 &&
       IsPromise<TupleElementOrVoid<std::tuple_size_v<TArgsTuple> - 1, TArgsTuple>>::value) {
     return 1;
   } else {
@@ -272,9 +341,15 @@ constexpr bool IsVoidResultCheck() noexcept {
 template <class TResult, class TArg>
 constexpr void ValidateCoroutineArg() noexcept {
   if constexpr (std::is_same_v<TResult, fire_and_forget>) {
+    // unfortunately __PRETTY_FUNCTION__ is not able to be put after a string literal
+    // so no detail information is provided for macOS
     static_assert(
         !std::is_reference_v<TArg> && !std::is_pointer_v<TArg>,
-        "Coroutine parameter must be passed by value for safe access: " __FUNCSIG__);
+        "Coroutine parameter must be passed by value for safe access"
+#ifndef __clang__
+        ": " __FUNCSIG__
+#endif
+    );
   }
 }
 
@@ -317,10 +392,45 @@ struct MethodSignatureMatchResult {
   bool IsResultMatching;
   bool AreArgsMatching;
   bool AreCallbacksMatching;
-  bool IsPromiseMathcing;
+  bool IsPromiseMatching;
   bool IsSucceeded;
 };
 
+template <class TInputArg, class TOtherInputArg>
+constexpr bool MatchInputArg() noexcept {
+  return std::is_same_v<TInputArg, TOtherInputArg>;
+}
+
+template <>
+constexpr bool MatchInputArg<std::wstring, std::string>() noexcept {
+  return true;
+}
+
+template <>
+constexpr bool MatchInputArg<std::string, std::wstring>() noexcept {
+  return true;
+}
+
+template <>
+constexpr bool MatchInputArg<std::string, winrt::hstring>() noexcept {
+  return true;
+}
+
+template <>
+constexpr bool MatchInputArg<winrt::hstring, std::string>() noexcept {
+  return true;
+}
+
+template <>
+constexpr bool MatchInputArg<std::wstring, winrt::hstring>() noexcept {
+  return true;
+}
+
+template <>
+constexpr bool MatchInputArg<winrt::hstring, std::wstring>() noexcept {
+  return true;
+}
+
 template <class TResult, class TInputArgs, class TOutputCallbacks, class TOutputPromises>
 struct MethodSignature {
   using Result = TResult;
@@ -342,7 +452,7 @@ struct MethodSignature {
 
   template <class TOtherInputArgs, size_t... I>
   static constexpr bool MatchInputArgs(std::index_sequence<I...>) noexcept {
-    return (std::is_same_v<std::tuple_element_t<I, InputArgs>, std::tuple_element_t<I, TOtherInputArgs>> && ...);
+    return (MatchInputArg<std::tuple_element_t<I, InputArgs>, std::tuple_element_t<I, TOtherInputArgs>>() && ...);
   }
 
   template <class TOtherOutputCallbacks, size_t... I>
@@ -370,10 +480,10 @@ struct MethodSignature {
           std::make_index_sequence<CallbackCount>{});
     }
 
-    result.IsPromiseMathcing = std::is_same_v<OutputPromises, typename TOtherMethodSignature::OutputPromises>;
+    result.IsPromiseMatching = std::is_same_v<OutputPromises, typename TOtherMethodSignature::OutputPromises>;
 
     result.IsSucceeded = result.IsResultMatching && result.ArgCountCompare == 0 && result.AreArgsMatching &&
-        result.CallbackCountCompare == 0 && result.AreCallbacksMatching && result.IsPromiseMathcing;
+        result.CallbackCountCompare == 0 && result.AreCallbacksMatching && result.IsPromiseMatching;
 
     return result;
   }
@@ -392,7 +502,7 @@ struct ModuleInitMethodInfo<void (TModule::*)(ReactContext const &) noexcept> {
   using MethodType = void (TModule::*)(ReactContext const &) noexcept;
 
   static InitializerDelegate GetInitializer(void *module, MethodType method) noexcept {
-    return [ module = static_cast<ModuleType *>(module), method ](ReactContext const &reactContext) noexcept {
+    return [module = static_cast<ModuleType *>(module), method](ReactContext const &reactContext) noexcept {
       (module->*method)(reactContext);
     };
   }
@@ -436,7 +546,7 @@ constexpr static bool MatchMethodSignature() noexcept {
     static_assert(matchResult.AreCallbacksMatching, "Method callback types are different from the method spec.");
   }
 
-  static_assert(matchResult.IsPromiseMathcing, "Method Promise type is different from the method spec.");
+  static_assert(matchResult.IsPromiseMatching, "Method Promise type is different from the method spec.");
 
   return matchResult.IsSucceeded;
 }
@@ -491,11 +601,11 @@ struct ModuleMethodInfo<TResult (TModule::*)(TArgs...) noexcept> : ModuleMethodI
       std::index_sequence<ArgIndex...>,
       std::index_sequence<CallbackIndex...>,
       std::index_sequence<PromiseIndex...>) noexcept {
-    return [ module, method ](
-        IJSValueReader const &argReader,
-        [[maybe_unused]] IJSValueWriter const &argWriter,
-        [[maybe_unused]] MethodResultCallback const &resolve,
-        [[maybe_unused]] MethodResultCallback const &reject) mutable noexcept {
+    return [module, method](
+               IJSValueReader const &argReader,
+               [[maybe_unused]] IJSValueWriter const &argWriter,
+               [[maybe_unused]] MethodResultCallback const &resolve,
+               [[maybe_unused]] MethodResultCallback const &reject) mutable noexcept {
       typename Super::InputArgTuple inputArgs{};
       ReadArgs(argReader, std::get<ArgIndex>(inputArgs)...);
       if constexpr (!Super::IsVoidResult) {
@@ -549,10 +659,10 @@ struct ModuleMethodInfo<TResult (*)(TArgs...) noexcept> : ModuleMethodInfoBase<T
       std::index_sequence<CallbackIndex...>,
       std::index_sequence<PromiseIndex...>) noexcept {
     return [method](
-        IJSValueReader const &argReader,
-        [[maybe_unused]] IJSValueWriter const &argWriter,
-        [[maybe_unused]] MethodResultCallback const &resolve,
-        [[maybe_unused]] MethodResultCallback const &reject) mutable noexcept {
+               IJSValueReader const &argReader,
+               [[maybe_unused]] IJSValueWriter const &argWriter,
+               [[maybe_unused]] MethodResultCallback const &resolve,
+               [[maybe_unused]] MethodResultCallback const &reject) mutable noexcept {
       typename Super::InputArgTuple inputArgs{};
       ReadArgs(argReader, std::get<ArgIndex>(inputArgs)...);
       if constexpr (!Super::IsVoidResult) {
@@ -613,12 +723,12 @@ struct ModuleSyncMethodInfo<TResult (TModule::*)(TArgs...) noexcept>
 
   template <size_t... I>
   static SyncMethodDelegate GetFunc(ModuleType *module, MethodType method, std::index_sequence<I...>) noexcept {
-    return [ module, method ](IJSValueReader const &argReader, IJSValueWriter const &argWriter) mutable noexcept {
+    return [module, method](IJSValueReader const &argReader, IJSValueWriter const &argWriter) mutable noexcept {
       using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
       ArgTuple typedArgs{};
       ReadArgs(argReader, std::get<I>(typedArgs)...);
       TResult result = (module->*method)(std::get<I>(std::move(typedArgs))...);
-      WriteArgs(argWriter, result);
+      WriteValue(argWriter, result);
     };
   }
 
@@ -646,7 +756,7 @@ struct ModuleSyncMethodInfo<TResult (*)(TArgs...) noexcept> : ModuleSyncMethodIn
       ArgTuple typedArgs{};
       ReadArgs(argReader, std::get<I>(typedArgs)...);
       TResult result = (*method)(std::get<I>(std::move(typedArgs))...);
-      WriteArgs(argWriter, result);
+      WriteValue(argWriter, result);
     };
   }
 
@@ -661,6 +771,21 @@ struct ModuleSyncMethodInfo<TResult (*)(TArgs...) noexcept> : ModuleSyncMethodIn
   }
 };
 
+template <class TFunc>
+struct ModuleEventEmitterInfo;
+
+// Instance EventEmitter function
+template <class TModule, typename TFuncType>
+struct ModuleEventEmitterInfo<TFuncType TModule::*> {
+  using ModuleType = TModule;
+
+  template <class TMethodSpec>
+  static constexpr bool Match() noexcept {
+    // TODO add validation of function type.
+    return true;
+  }
+};
+
 template <class TField>
 struct ModuleConstFieldInfo;
 
@@ -670,8 +795,7 @@ struct ModuleConstFieldInfo<TValue TModule::*> {
   using FieldType = TValue TModule::*;
 
   static ConstantProviderDelegate GetConstantProvider(void *module, std::wstring_view name, FieldType field) noexcept {
-    return
-        [ module = static_cast<ModuleType *>(module), name, field ](IJSValueWriter const &argWriter) mutable noexcept {
+    return [module = static_cast<ModuleType *>(module), name, field](IJSValueWriter const &argWriter) mutable noexcept {
       WriteProperty(argWriter, name, module->*field);
     };
   }
@@ -683,9 +807,7 @@ struct ModuleConstFieldInfo<TValue *> {
 
   static ConstantProviderDelegate
   GetConstantProvider(void * /*module*/, std::wstring_view name, FieldType field) noexcept {
-    return [ name, field ](IJSValueWriter const &argWriter) mutable noexcept {
-      WriteProperty(argWriter, name, *field);
-    };
+    return [name, field](IJSValueWriter const &argWriter) mutable noexcept { WriteProperty(argWriter, name, *field); };
   }
 };
 
@@ -714,7 +836,7 @@ struct ModuleConstantInfo<void (TModule::*)(ReactConstantProvider &) noexcept> {
   using MethodType = void (TModule::*)(ReactConstantProvider &) noexcept;
 
   static ConstantProviderDelegate GetConstantProvider(void *module, MethodType method) noexcept {
-    return [ module = static_cast<ModuleType *>(module), method ](IJSValueWriter const &argWriter) mutable noexcept {
+    return [module = static_cast<ModuleType *>(module), method](IJSValueWriter const &argWriter) mutable noexcept {
       ReactConstantProvider constantProvider{argWriter};
       (module->*method)(constantProvider);
     };
@@ -733,6 +855,31 @@ struct ModuleConstantInfo<void (*)(ReactConstantProvider &) noexcept> {
   }
 };
 
+template <class TModule, class TStruct>
+struct ModuleConstantInfo<TStruct (TModule::*)() noexcept> {
+  using ModuleType = TModule;
+  using MethodType = TStruct (TModule::*)() noexcept;
+
+  static ConstantProviderDelegate GetConstantProvider(void *module, MethodType method) noexcept {
+    return [module = static_cast<ModuleType *>(module), method](IJSValueWriter const &argWriter) mutable noexcept {
+      auto constants = (module->*method)();
+      WriteProperties(argWriter, constants);
+    };
+  }
+};
+
+template <class TStruct>
+struct ModuleConstantInfo<TStruct (*)() noexcept> {
+  using MethodType = TStruct (*)() noexcept;
+
+  static ConstantProviderDelegate GetConstantProvider(void * /*module*/, MethodType method) noexcept {
+    return [method](IJSValueWriter const &argWriter) mutable noexcept {
+      auto constants = (*method)();
+      WriteProperties(argWriter, constants);
+    };
+  }
+};
+
 template <class TField>
 struct ModuleEventFieldInfo;
 
@@ -741,20 +888,40 @@ struct ModuleEventFieldInfo<TFunc<void(TArgs...)> TModule::*> {
   using ModuleType = TModule;
   using EventType = TFunc<void(TArgs...)>;
   using FieldType = EventType TModule::*;
+  using IsTurboModule = IsReactTurboModule<ModuleType>;
 
   static InitializerDelegate GetEventHandlerInitializer(
       void *module,
       FieldType field,
       std::wstring_view eventName,
       std::wstring_view eventEmitterName) noexcept {
-    return [ module = static_cast<ModuleType *>(module), field, eventName, eventEmitterName ](
-        IReactContext const &reactContext) noexcept {
-      module->*field = [ reactContext, eventEmitterName, eventName ](TArgs... args) noexcept {
-        reactContext.EmitJSEvent(
-            eventEmitterName, eventName, [&args...]([[maybe_unused]] IJSValueWriter const &argWriter) noexcept {
-              (void)argWriter; // [[maybe_unused]] above does not work
-              (WriteValue(argWriter, args), ...);
-            });
+    if constexpr (IsTurboModule::value) {
+      return [module = static_cast<ModuleType *>(module), field](IReactContext const &) noexcept {
+        // Default emitter will do nothing
+        // This will be replaced with a method that will call the jsi EventEmitter when JS requests the emitter
+        module->*field = [](TArgs... args) noexcept {};
+      };
+    } else {
+      return [module = static_cast<ModuleType *>(module), field, eventName, eventEmitterName](
+                 IReactContext const &reactContext) noexcept {
+        module->*field = [reactContext, eventEmitterName, eventName](TArgs... args) noexcept {
+          reactContext.EmitJSEvent(
+              eventEmitterName, eventName, [&args...]([[maybe_unused]] IJSValueWriter const &argWriter) noexcept {
+                (void)argWriter; // [[maybe_unused]] above does not work
+                (WriteValue(argWriter, args), ...);
+              });
+        };
+      };
+    }
+  }
+
+  static EventEmitterInitializerDelegate GetEventEmitterInitializer(void *module, FieldType field) noexcept {
+    return [module = static_cast<ModuleType *>(module), field](EmitEventSetterDelegate const &emitEventDelegate) {
+      module->*field = [emitEventDelegate](TArgs... args) noexcept {
+        emitEventDelegate([&args...]([[maybe_unused]] IJSValueWriter const &argWriter) noexcept {
+          (void)argWriter; // [[maybe_unused]] above does not work
+          (WriteValue(argWriter, args), ...);
+        });
       };
     };
   }
@@ -774,9 +941,9 @@ struct ModuleFunctionFieldInfo<TFunc<void(TArgs...)> TModule::*> {
       FieldType field,
       std::wstring_view functionName,
       std::wstring_view moduleName) noexcept {
-    return [ module = static_cast<ModuleType *>(module), field, functionName, moduleName ](
-        IReactContext const &reactContext) noexcept {
-      module->*field = [ reactContext, functionName, moduleName ](TArgs... args) noexcept {
+    return [module = static_cast<ModuleType *>(module), field, functionName, moduleName](
+               IReactContext const &reactContext) noexcept {
+      module->*field = [reactContext, functionName, moduleName](TArgs... args) noexcept {
         reactContext.CallJSFunction(moduleName, functionName, [&args...](IJSValueWriter const &argWriter) noexcept {
           WriteArgs(argWriter, args...);
         });
@@ -823,6 +990,7 @@ enum class ReactMemberKind {
   AsyncMethod,
   SyncMethod,
   ConstantMethod,
+  ConstantStrongTypedMethod,
   ConstantField,
   EventField,
   FunctionField,
@@ -841,6 +1009,7 @@ using ReactInitMethodAttribute = ReactMemberAttribute<ReactMemberKind::InitMetho
 using ReactAsyncMethodAttribute = ReactMemberAttribute<ReactMemberKind::AsyncMethod>;
 using ReactSyncMethodAttribute = ReactMemberAttribute<ReactMemberKind::SyncMethod>;
 using ReactConstantMethodAttribute = ReactMemberAttribute<ReactMemberKind::ConstantMethod>;
+using ReactConstantStrongTypedMethodAttribute = ReactMemberAttribute<ReactMemberKind::ConstantStrongTypedMethod>;
 using ReactConstantFieldAttribute = ReactMemberAttribute<ReactMemberKind::ConstantField>;
 using ReactEventFieldAttribute = ReactMemberAttribute<ReactMemberKind::EventField>;
 using ReactFunctionFieldAttribute = ReactMemberAttribute<ReactMemberKind::FunctionField>;
@@ -887,6 +1056,8 @@ struct ReactModuleBuilder {
       RegisterSyncMethod(member, attributeInfo.JSMemberName);
     } else if constexpr (std::is_same_v<TAttribute, ReactConstantMethodAttribute>) {
       RegisterConstantMethod(member);
+    } else if constexpr (std::is_same_v<TAttribute, ReactConstantStrongTypedMethodAttribute>) {
+      RegisterConstantStrongTypedMethod(member);
     } else if constexpr (std::is_same_v<TAttribute, ReactConstantFieldAttribute>) {
       RegisterConstantField(member, attributeInfo.JSMemberName);
     } else if constexpr (std::is_same_v<TAttribute, ReactEventFieldAttribute>) {
@@ -921,6 +1092,12 @@ struct ReactModuleBuilder {
     m_moduleBuilder.AddConstantProvider(constantProvider);
   }
 
+  template <class TMethod>
+  void RegisterConstantStrongTypedMethod(TMethod method) noexcept {
+    auto constantProvider = ModuleConstantInfo<TMethod>::GetConstantProvider(m_module, method);
+    m_moduleBuilder.AddConstantProvider(constantProvider);
+  }
+
   template <class TField>
   void RegisterConstantField(TField field, std::wstring_view name) noexcept {
     auto constantProvider = ModuleConstFieldInfo<TField>::GetConstantProvider(m_module, name, field);
@@ -933,6 +1110,10 @@ struct ReactModuleBuilder {
     auto eventHandlerInitializer = ModuleEventFieldInfo<TField>::GetEventHandlerInitializer(
         m_module, field, eventName, !eventEmitterName.empty() ? eventEmitterName : m_eventEmitterName);
     m_moduleBuilder.AddInitializer(eventHandlerInitializer);
+    if constexpr (ModuleEventFieldInfo<TField>::IsTurboModule::value) {
+      auto eventEmitterInitializer = ModuleEventFieldInfo<TField>::GetEventEmitterInitializer(m_module, field);
+      m_moduleBuilder.AddEventEmitter(eventName, eventEmitterInitializer);
+    }
   }
 
   template <class TField>
@@ -1001,17 +1182,41 @@ struct ReactModuleVerifier {
   VerificationResult m_result;
 };
 
+template <class TModule, class TConstantType>
+struct ReactTypedConstantVerifier {
+  template <int I>
+  constexpr void RegisterModule(std::wstring_view /*_*/, std::wstring_view /*_*/, ReactAttributeId<I>) noexcept {
+    ReactMemberInfoIterator<TModule>{}.template ForEachMember<I + 1>(*this);
+  }
+
+  template <class TMember, class TAttribute, int I>
+  constexpr void Visit(
+      [[maybe_unused]] TMember /*member*/,
+      ReactAttributeId<I> /*attributeId*/,
+      TAttribute /*attributeInfo*/) noexcept {
+    if constexpr (std::is_same_v<TAttribute, ReactConstantStrongTypedMethodAttribute>) {
+      using T1 = TConstantType (*)() noexcept;
+      using T2 = TConstantType (TModule::*)() noexcept;
+      if constexpr (std::is_same_v<TMember, T1> || std::is_same_v<TMember, T2>) {
+        m_matchedCount++;
+      }
+    }
+  }
+
+  int m_matchedCount{0};
+};
+
 template <class TModule, int I, class TMethodSpec>
 struct ReactMethodVerifier {
   static constexpr bool Verify() noexcept {
     ReactMethodVerifier verifier{};
-    ReactMemberInfoIterator<TModule>{}.GetMemberInfo<I>(verifier);
+    ReactMemberInfoIterator<TModule>{}.template GetMemberInfo<I>(verifier);
     return verifier.m_result;
   }
 
-  template <class TMember, class TAttribute, int I>
+  template <class TMember, class TAttribute, int I2>
   constexpr void
-  Visit([[maybe_unused]] TMember member, ReactAttributeId<I> /*attributeId*/, TAttribute /*attributeInfo*/) noexcept {
+  Visit([[maybe_unused]] TMember member, ReactAttributeId<I2> /*attributeId*/, TAttribute /*attributeInfo*/) noexcept {
     m_result = ModuleMethodInfo<TMember>::template Match<TMethodSpec>();
   }
 
@@ -1023,13 +1228,13 @@ template <class TModule, int I, class TMethodSpec>
 struct ReactSyncMethodVerifier {
   static constexpr bool Verify() noexcept {
     ReactSyncMethodVerifier verifier{};
-    ReactMemberInfoIterator<TModule>{}.GetMemberInfo<I>(verifier);
+    ReactMemberInfoIterator<TModule>{}.template GetMemberInfo<I>(verifier);
     return verifier.m_result;
   }
 
-  template <class TMember, class TAttribute, int I>
+  template <class TMember, class TAttribute, int I2>
   constexpr void
-  Visit([[maybe_unused]] TMember member, ReactAttributeId<I> /*attributeId*/, TAttribute /*attributeInfo*/) noexcept {
+  Visit([[maybe_unused]] TMember member, ReactAttributeId<I2> /*attributeId*/, TAttribute /*attributeInfo*/) noexcept {
     m_result = ModuleSyncMethodInfo<TMember>::template Match<TMethodSpec>();
   }
 
@@ -1037,7 +1242,63 @@ struct ReactSyncMethodVerifier {
   bool m_result{false};
 };
 
+template <class TModule, int I, class TMethodSpec>
+struct ReactEventEmitterVerifier {
+  static constexpr bool IsTurboModule() noexcept {
+    return IsReactTurboModule<TModule>::value;
+  }
+
+  static constexpr bool Verify() noexcept {
+    ReactEventEmitterVerifier verifier{};
+    ReactMemberInfoIterator<TModule>{}.template GetMemberInfo<I>(verifier);
+    return verifier.m_result;
+  }
+
+  template <class TMember, class TAttribute, int I2>
+  constexpr void
+  Visit([[maybe_unused]] TMember member, ReactAttributeId<I2> /*attributeId*/, TAttribute /*attributeInfo*/) noexcept {
+    m_result = ModuleEventEmitterInfo<TMember>::template Match<TMethodSpec>();
+  }
+
+ private:
+  bool m_result{false};
+};
+
 struct TurboModuleSpec {
+  template <class TSignature>
+  struct TypedConstant {
+    constexpr TypedConstant(int index) : Index{index} {}
+
+    int Index;
+  };
+
+  struct ConstantCheckResult {
+    bool IsMethodFound{false};
+    bool IsMethodUnique{true};
+  };
+
+  template <class TModule, class TModuleSpec, class TConstantType>
+  static constexpr ConstantCheckResult CheckConstant(TypedConstant<TConstantType>) noexcept {
+    ReactTypedConstantVerifier<TModule, TConstantType> verifier;
+    GetReactModuleInfo(static_cast<TModule *>(nullptr), verifier);
+    ConstantCheckResult result;
+    result.IsMethodFound = verifier.m_matchedCount > 0;
+    result.IsMethodUnique = verifier.m_matchedCount < 2;
+    return result;
+  }
+
+  template <class TModule, class TModuleSpec, size_t... I>
+  static constexpr auto CheckConstantsHelper(std::index_sequence<I...>) noexcept {
+    return std::array<ConstantCheckResult, sizeof...(I)>{
+        CheckConstant<TModule, TModuleSpec>(std::get<I>(TModuleSpec::constants))...};
+  }
+
+  template <class TModule, class TModuleSpec>
+  static constexpr auto CheckConstants() noexcept {
+    return CheckConstantsHelper<TModule, TModuleSpec>(
+        std::make_index_sequence<std::tuple_size_v<decltype(TModuleSpec::constants)>>{});
+  }
+
   struct BaseMethodSpec {
     constexpr BaseMethodSpec(int index, std::wstring_view name) : Index{index}, Name{name} {}
 
@@ -1049,14 +1310,21 @@ struct TurboModuleSpec {
   struct Method : BaseMethodSpec {
     using BaseMethodSpec::BaseMethodSpec;
     using Signature = typename ModuleMethodInfoBase<TSignature>::Signature;
-    static constexpr bool IsSynchronous = false;
+    static constexpr ReactMemberKind MemberKind = ReactMemberKind::AsyncMethod;
   };
 
   template <class TSignature>
   struct SyncMethod : BaseMethodSpec {
     using BaseMethodSpec::BaseMethodSpec;
     using Signature = typename ModuleSyncMethodInfoBase<TSignature>::Signature;
-    static constexpr bool IsSynchronous = true;
+    static constexpr ReactMemberKind MemberKind = ReactMemberKind::SyncMethod;
+  };
+
+  template <class TSignature>
+  struct EventEmitter : BaseMethodSpec {
+    using BaseMethodSpec::BaseMethodSpec;
+    // using Signature = typename ModuleEventEmitterInfo<TSignature>::Signature;
+    static constexpr ReactMemberKind MemberKind = ReactMemberKind::EventField;
   };
 
   template <class... TArgs>
@@ -1069,27 +1337,36 @@ struct TurboModuleSpec {
     bool IsUniqueName{false};
     bool IsMethodFound{false};
     bool IsSignatureMatching{true};
+    bool IsTurboModule{false};
   };
 
   template <class TModule, class TModuleSpec, size_t I>
   static constexpr MethodCheckResult CheckMethod() noexcept {
     constexpr VerificationResult verificationResult = ReactModuleVerifier<TModule>::VerifyMember(
-        std::get<I>(TModuleSpec::methods).Name,
-        std::get<I>(TModuleSpec::methods).IsSynchronous ? ReactMemberKind::SyncMethod : ReactMemberKind::AsyncMethod);
+        std::get<I>(TModuleSpec::methods).Name, std::get<I>(TModuleSpec::methods).MemberKind);
     MethodCheckResult result{};
     result.IsUniqueName = verificationResult.MethodNameCount <= 1;
     result.IsMethodFound = verificationResult.MatchCount == 1;
     if constexpr (verificationResult.MatchCount == 1) {
-      if constexpr (std::get<I>(TModuleSpec::methods).IsSynchronous) {
+      if constexpr (std::get<I>(TModuleSpec::methods).MemberKind == ReactMemberKind::SyncMethod) {
         result.IsSignatureMatching = ReactSyncMethodVerifier<
             TModule,
             verificationResult.MatchedMemberId,
             RemoveConstRef<decltype(std::get<I>(TModuleSpec::methods))>>::Verify();
-      } else {
+      } else if constexpr (std::get<I>(TModuleSpec::methods).MemberKind == ReactMemberKind::AsyncMethod) {
         result.IsSignatureMatching = ReactMethodVerifier<
             TModule,
             verificationResult.MatchedMemberId,
             RemoveConstRef<decltype(std::get<I>(TModuleSpec::methods))>>::Verify();
+      } else if constexpr (std::get<I>(TModuleSpec::methods).MemberKind == ReactMemberKind::EventField) {
+        result.IsTurboModule = ReactEventEmitterVerifier<
+            TModule,
+            verificationResult.MatchedMemberId,
+            RemoveConstRef<decltype(std::get<I>(TModuleSpec::methods))>>::IsTurboModule();
+        result.IsSignatureMatching = ReactEventEmitterVerifier<
+            TModule,
+            verificationResult.MatchedMemberId,
+            RemoveConstRef<decltype(std::get<I>(TModuleSpec::methods))>>::Verify();
       }
     }
 
@@ -1111,19 +1388,20 @@ struct TurboModuleSpec {
 // The default factory for the TModule.
 // It wraps up the TModule into a ReactNonAbiValue to be passed through the ABI boundary.
 template <class TModule>
-inline std::tuple<IInspectable, TModule *> MakeDefaultReactModuleWrapper() noexcept {
+inline std::tuple<winrt::Windows::Foundation::IInspectable, TModule *> MakeDefaultReactModuleWrapper() noexcept {
   ReactNonAbiValue<TModule> moduleWrapper{std::in_place};
   TModule *module = moduleWrapper.GetPtr();
-  return std::tuple<IInspectable, TModule *>{std::move(moduleWrapper), module};
+  return std::tuple<winrt::Windows::Foundation::IInspectable, TModule *>{std::move(moduleWrapper), module};
 }
 
 // The default factory for TModule inherited from enable_shared_from_this<T>.
 // It wraps up the TModule into an  std::shared_ptr before giving it to ReactNonAbiValue.
 template <class TModule>
-inline std::tuple<IInspectable, TModule *> MakeDefaultSharedPtrReactModuleWrapper() noexcept {
+inline std::tuple<winrt::Windows::Foundation::IInspectable, TModule *>
+MakeDefaultSharedPtrReactModuleWrapper() noexcept {
   ReactNonAbiValue<std::shared_ptr<TModule>> moduleWrapper{std::in_place, std::make_shared<TModule>()};
   TModule *module = moduleWrapper.GetPtr()->get();
-  return std::tuple<IInspectable, TModule *>{std::move(moduleWrapper), module};
+  return std::tuple<winrt::Windows::Foundation::IInspectable, TModule *>{std::move(moduleWrapper), module};
 }
 
 namespace Internal {
@@ -1157,13 +1435,28 @@ inline constexpr auto GetReactModuleFactory(TModule * /*moduleNullPtr*/, int * /
 // Type traits for TModule. It defines a factory to create the module and its ABI-safe wrapper.
 template <class TModule>
 struct ReactModuleTraits {
-  using FactoryType = std::tuple<IInspectable, TModule *>() noexcept;
+  using FactoryType = std::tuple<winrt::Windows::Foundation::IInspectable, TModule *>() noexcept;
   static constexpr FactoryType *Factory = GetReactModuleFactory((TModule *)nullptr, 0);
 };
 
+template <class TModule, typename = void>
+struct ReactModuleSpecOrVoid {
+  using Type = void;
+};
+
+template <class TModule>
+struct ReactModuleSpecOrVoid<TModule, std::enable_if_t<(sizeof(typename TModule::ModuleSpec) >= 0)>> {
+  using Type = typename TModule::ModuleSpec;
+};
+
 // Create a module provider for TModule type.
+// If TModule::ModuleSpec exists, it ensures that the module satisfies the spec.
 template <class TModule>
 inline ReactModuleProvider MakeModuleProvider() noexcept {
+  using TModuleSpec = typename ReactModuleSpecOrVoid<TModule>::Type;
+  if constexpr (!std::is_same_v<void, TModuleSpec>) {
+    TModuleSpec::template ValidateModule<TModule>();
+  }
   return [](IReactModuleBuilder const &moduleBuilder) noexcept {
     auto [moduleWrapper, module] = ReactModuleTraits<TModule>::Factory();
     ReactModuleBuilder builder{module, moduleBuilder};
@@ -1173,13 +1466,26 @@ inline ReactModuleProvider MakeModuleProvider() noexcept {
   };
 }
 
-// Create a module provider for TModule type that satisfies the TModuleSpec.
-template <class TModule, class TModuleSpec>
+// Create a module provider for TModule type.
+// It is the same to MakeModuleProvider but it requires TModule::ModuleSpec to exist.
+template <class TModule>
 inline ReactModuleProvider MakeTurboModuleProvider() noexcept {
-  TModuleSpec::template ValidateModule<TModule>();
+  using TModuleSpec = typename ReactModuleSpecOrVoid<TModule>::Type;
+  static_assert(
+      !std::is_same_v<void, TModuleSpec>,
+      "TModule::ModuleSpec must exist and it specifies the specification for this module.");
   return MakeModuleProvider<TModule>();
 }
 
+// Clang does not allow a virtual function address to be a constexpr statement
+#if !defined(CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS)
+#if defined(__clang__)
+#define CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS
+#else
+#define CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS constexpr
+#endif
+#endif
+
 } // namespace winrt::Microsoft::ReactNative
 
 namespace React {