feat: implement interop.FunctionReference

Author: DjDeveloperr

include/Interop.h

@@ -1,6 +1,7 @@
 #ifndef INTEROP_H
 #define INTEROP_H
 
+#include "Closure.h"
 #include "TypeConv.h"
 #include "js_native_api.h"
 
@@ -61,6 +62,26 @@ class Reference {
   napi_ref initValue = nullptr;
 };
 
+class FunctionReference {
+public:
+  static napi_value defineJSClass(napi_env env);
+
+  static FunctionReference *unwrap(napi_env env, napi_value value);
+
+  static napi_value constructor(napi_env env, napi_callback_info info);
+
+  static void finalize(napi_env env, void *data, void *hint);
+
+  FunctionReference(napi_env env, napi_ref ref) : env(env), ref(ref){};
+  ~FunctionReference();
+
+  void *getFunctionPointer(MDSectionOffset offset);
+
+  napi_env env;
+  napi_ref ref;
+  std::shared_ptr<Closure> closure = nullptr;
+};
+
 } // namespace objc_bridge
 
 #endif /* INTEROP_H */

src/Interop.mm

@@ -1,11 +1,13 @@
 #include "Interop.h"
+#include "Metadata.h"
 #include "ObjCBridge.h"
 #include "Util.h"
 #include "js_native_api.h"
 #include "js_native_api_types.h"
 #include "node_api_util.h"
 
 #import <Foundation/Foundation.h>
+#include <memory>
 
 namespace objc_bridge {
 
@@ -63,6 +65,8 @@ void registerInterop(napi_env env, napi_value global) {
   napi_value Reference = Reference::defineJSClass(env);
   bridgeState->referenceClass = make_ref(env, Reference);
 
+  napi_value FunctionReference = FunctionReference::defineJSClass(env);
+
   const napi_property_descriptor properties[] = {
       {
           .utf8name = "Pointer",
@@ -82,6 +86,15 @@ void registerInterop(napi_env env, napi_value global) {
           .data = nullptr,
           .method = nullptr,
       },
+      {
+          .utf8name = "FunctionReference",
+          .attributes = napi_enumerable,
+          .getter = nullptr,
+          .setter = nullptr,
+          .value = FunctionReference,
+          .data = nullptr,
+          .method = nullptr,
+      },
       {
           .utf8name = "types",
           .attributes = napi_enumerable,
@@ -600,4 +613,52 @@ napi_value interop_bufferFromData(napi_env env, napi_callback_info info) {
   }
 }
 
+napi_value FunctionReference::defineJSClass(napi_env env) {
+  napi_value constructor;
+  napi_define_class(env, "FunctionReference", NAPI_AUTO_LENGTH,
+                    FunctionReference::constructor, nullptr, 0, nullptr,
+                    &constructor);
+
+  return constructor;
+}
+
+FunctionReference *FunctionReference::unwrap(napi_env env, napi_value value) {
+  FunctionReference *ref = nullptr;
+  napi_unwrap(env, value, (void **)&ref);
+  return ref;
+}
+
+void FunctionReference::finalize(napi_env env, void *data, void *hint) {
+  FunctionReference *ref = (FunctionReference *)data;
+  delete ref;
+}
+
+napi_value FunctionReference::constructor(napi_env env,
+                                          napi_callback_info info) {
+  napi_value jsThis;
+  size_t argc = 1;
+  napi_value arg;
+  napi_get_cb_info(env, info, &argc, &arg, &jsThis, nullptr);
+
+  FunctionReference *reference = new FunctionReference(env, make_ref(env, arg));
+
+  napi_ref ref;
+  napi_wrap(env, jsThis, reference, FunctionReference::finalize, nullptr, &ref);
+
+  return jsThis;
+}
+
+FunctionReference::~FunctionReference() { napi_delete_reference(env, ref); }
+
+void *FunctionReference::getFunctionPointer(MDSectionOffset offset) {
+  if (closure == nullptr) {
+    closure = std::make_shared<Closure>(
+        ObjCBridgeState::InstanceData(env)->metadata, offset, true);
+    closure->env = env;
+    closure->func = ref;
+  }
+
+  return closure->fnptr;
+}
+
 } // namespace objc_bridge

src/TypeConv.mm

@@ -767,11 +767,8 @@ void toNative(napi_env env, napi_value value, void *result, bool *shouldFree,
     }
 
     case napi_object: {
-      NAPI_GUARD(napi_unwrap(env, value, res)) {
-        NAPI_THROW_LAST_ERROR
-        *res = nullptr;
-        return;
-      }
+      FunctionReference *ref = FunctionReference::unwrap(env, value);
+      *res = ref->getFunctionPointer(signatureOffset);
     }
 
     case napi_function: {