Add helper for treating arbitrary function as member function

src/callback.h

@@ -75,6 +75,29 @@ struct Type<T, typename std::enable_if<
   }
 };
 
+// Helper mark a normal function as member function.
+template<typename T>
+struct MemberFunctionHolder {
+  T func;
+};
+
+template<typename T>
+struct Type<MemberFunctionHolder<T>,
+            std::enable_if_t<
+                internal::IsFunctionConversionSupported<T>::value>> {
+  static constexpr const char* name = "Function";
+  static inline napi_status ToNode(napi_env env, MemberFunctionHolder<T> value,
+                                   napi_value* result) {
+    return internal::CreateNodeFunction(env, value.func, result,
+                                        HolderIsFirstArgument);
+  }
+};
+
+template<typename T>
+inline MemberFunctionHolder<T> MemberFunction(T func) {
+  return MemberFunctionHolder<T>{func};
+}
+
 }  // namespace ki
 
 #endif  // SRC_CALLBACK_H_

src/callback_internal.h

@@ -328,12 +328,13 @@ inline std::function<NodeCallbackSig> CreateNodeCallbackWithHolder(
 // JavaScript arguments are automatically converted via Type<T>, as is
 // the return value of the C++ function, if any.
 template<typename T>
-inline napi_status CreateNodeFunction(napi_env env, T func,
-                                      napi_value* result) {
+inline napi_status CreateNodeFunction(napi_env env, T func, napi_value* result,
+                                      int flags = 0) {
   using Factory = CallbackHolderFactory<T>;
   using RunType = typename Factory::RunType;
   using HolderT = typename Factory::HolderT;
-  auto holder = std::make_unique<HolderT>(Factory::Create(std::move(func)));
+  auto holder = std::make_unique<HolderT>(Factory::Create(std::move(func),
+                                                          flags));
   napi_value intermediate;
   napi_status s = napi_create_function(env, nullptr, 0,
                                        &ReturnToNode<RunType>::Invoke,