objc-js 0.0.7 → 0.0.9

package/binding.gyp

@@ -0,0 +1,33 @@
+{
+    "targets": [
+        {
+            "target_name": "nobjc_native",
+            "sources": [
+                "src/native/nobjc.mm",
+                "src/native/ObjcObject.mm",
+                "src/native/protocol-impl.mm"
+            ],
+            "defines": [
+                "NODE_ADDON_API_CPP_EXCEPTIONS",
+                "NAPI_VERSION=6"
+            ],
+            "include_dirs": [
+                "<!@(node -p \"require('node-addon-api').include\")"
+            ],
+            "dependencies": [
+                "<!(node -p \"require('node-addon-api').gyp\")"
+            ],
+            "xcode_settings": {
+                "MACOSX_DEPLOYMENT_TARGET": "13.3",
+                "CLANG_CXX_LIBRARY": "libc++",
+                "OTHER_CPLUSPLUSFLAGS": [
+                    "-std=c++20",
+                    "-fexceptions"
+                ],
+                "OTHER_CFLAGS": [
+                    "-fobjc-arc"
+                ]
+            }
+        }
+    ]
+}

package/dist/index.js

@@ -1,4 +1,5 @@
 import { LoadLibrary, GetClassObject, ObjcObject, GetPointer, FromPointer, CreateProtocolImplementation } from "./native.js";
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
 const NATIVE_OBJC_OBJECT = Symbol("nativeObjcObject");
 class NobjcLibrary {
     constructor(library) {
@@ -24,6 +25,7 @@ function ObjcSelectorToNobjcMethodName(selector) {
 }
 class NobjcObject {
     constructor(object) {
+        // Create the proxy handler
         const handler = {
             has(target, p) {
                 // Return true for the special Symbol to enable unwrapping
@@ -54,7 +56,12 @@ class NobjcObject {
                 }
                 // handle toString separately
                 if (methodName === "toString") {
-                    return () => String(object.$msgSend("description"));
+                    // if the receiver has a UTF8String method, use it to get the string representation
+                    if ("UTF8String" in receiver) {
+                        return () => String(object.$msgSend("UTF8String"));
+                    }
+                    // Otherwise, use the description method
+                    return () => String(wrapObjCObjectIfNeeded(object.$msgSend("description")));
                 }
                 // handle other built-in Object.prototype properties
                 const builtInProps = [
@@ -79,7 +86,12 @@ class NobjcObject {
                 return NobjcMethod(object, methodName);
             }
         };
-        return new Proxy(object, handler);
+        // Create the proxy
+        const proxy = new Proxy(object, handler);
+        // This is used to override the default inspect behavior for the object. (console.log)
+        object[customInspectSymbol] = () => proxy.toString();
+        // Return the proxy
+        return proxy;
     }
 }
 function unwrapArg(arg) {

package/package.json

@@ -17,9 +17,12 @@
   },
   "files": [
     "dist/",
-    "build/Release/nobjc_native.node"
+    "build/Release/nobjc_native.node",
+    "binding.gyp",
+    "src/native"
   ],
   "scripts": {
+    "install": "node-gyp rebuild",
     "build-native": "node-gyp build",
     "build-scripts": "tsc --project scripts/tsconfig.json",
     "build-source": "tsc --project src/ts/tsconfig.json",
@@ -36,13 +39,15 @@
     "format": "prettier --write \"**/*.{ts,js,json,md}\"",
     "preinstall-disabled": "npm run build-scripts && npm run make-clangd-config"
   },
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Objective-C bridge for Node.js",
   "main": "dist/index.js",
+  "dependencies": {
+    "node-addon-api": "^8.5.0"
+  },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/node": "^20.0.0",
-    "node-addon-api": "^8.5.0",
     "node-gyp": "^11.4.2",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3"

package/src/native/ObjcObject.h

@@ -0,0 +1,34 @@
+#include <napi.h>
+#include <objc/objc.h>
+#include <optional>
+#include <variant>
+
+#ifndef OBJCOBJECT_H
+#define OBJCOBJECT_H
+
+class ObjcObject : public Napi::ObjectWrap<ObjcObject> {
+public:
+  __strong id objcObject;
+  static Napi::FunctionReference constructor;
+  static void Init(Napi::Env env, Napi::Object exports);
+  ObjcObject(const Napi::CallbackInfo &info)
+      : Napi::ObjectWrap<ObjcObject>(info), objcObject(nil) {
+    if (info.Length() == 1 && info[0].IsExternal()) {
+      // This better be an Napi::External<id>! We lost the type info at runtime.
+      Napi::External<id> external = info[0].As<Napi::External<id>>();
+      objcObject = *(external.Data());
+      return;
+    }
+    // If someone tries `new ObjcObject()` from JS, forbid it:
+    Napi::TypeError::New(info.Env(), "Cannot construct directly")
+        .ThrowAsJavaScriptException();
+  }
+  static Napi::Object NewInstance(Napi::Env env, id obj);
+  ~ObjcObject() = default;
+
+private:
+  Napi::Value $MsgSend(const Napi::CallbackInfo &info);
+  Napi::Value GetPointer(const Napi::CallbackInfo &info);
+};
+
+#endif // OBJCOBJECT_H

package/src/native/ObjcObject.mm

@@ -0,0 +1,150 @@
+#include "ObjcObject.h"
+#include "bridge.h"
+#include <Foundation/Foundation.h>
+#include <napi.h>
+#include <objc/objc.h>
+#include <vector>
+
+Napi::FunctionReference ObjcObject::constructor;
+
+void ObjcObject::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func =
+      DefineClass(env, "ObjcObject",
+                  {
+                      InstanceMethod("$msgSend", &ObjcObject::$MsgSend),
+                      InstanceMethod("$getPointer", &ObjcObject::GetPointer),
+                  });
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("ObjcObject", func);
+}
+
+Napi::Object ObjcObject::NewInstance(Napi::Env env, id obj) {
+  Napi::EscapableHandleScope scope(env);
+  // `obj` is already a pointer, technically, but the Napi::External
+  //  API expects a pointer, so we have to pointer to the pointer.
+  Napi::Object jsObj = constructor.New({Napi::External<id>::New(env, &obj)});
+  return scope.Escape(jsObj).ToObject();
+}
+
+Napi::Value ObjcObject::$MsgSend(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected at least one string argument")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string selectorName = info[0].As<Napi::String>().Utf8Value();
+  SEL selector = sel_registerName(selectorName.c_str());
+
+  if (![objcObject respondsToSelector:selector]) {
+    Napi::Error::New(env, "Selector not found on object")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  NSMethodSignature *methodSignature =
+      [objcObject methodSignatureForSelector:selector];
+  if (methodSignature == nil) {
+    Napi::Error::New(env, "Failed to get method signature")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // The first two arguments of the signature are the target and selector.
+  const size_t expectedArgCount = [methodSignature numberOfArguments] - 2;
+
+  // The first provided argument is the selector name.
+  const size_t providedArgCount = info.Length() - 1;
+
+  if (providedArgCount != expectedArgCount) {
+    std::string errorMessageStr =
+        std::format("Selector {} (on {}) expected {} argument(s), but got {}",
+                    selectorName, std::string(object_getClassName(objcObject)),
+                    expectedArgCount, providedArgCount);
+    const char *errorMessage = errorMessageStr.c_str();
+    Napi::Error::New(env, errorMessage).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if ([methodSignature isOneway]) {
+    Napi::Error::New(env, "One-way methods are not supported")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  const char *returnType =
+      SimplifyTypeEncoding([methodSignature methodReturnType]);
+  const char *validReturnTypes = "cislqCISLQfdB*v@#:";
+  if (strlen(returnType) != 1 ||
+      strchr(validReturnTypes, *returnType) == nullptr) {
+    Napi::TypeError::New(env, "Unsupported return type (pre-invoke)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  NSInvocation *invocation =
+      [NSInvocation invocationWithMethodSignature:methodSignature];
+  [invocation setSelector:selector];
+  [invocation setTarget:objcObject];
+
+  // Store all arguments to keep them alive until after invoke.
+  // This is critical for string arguments where we pass a pointer to the
+  // internal buffer of a std::string - if the string is destroyed before
+  // invoke, the pointer becomes dangling.
+  std::vector<ObjcType> storedArgs;
+  storedArgs.reserve(info.Length() - 1);
+
+  for (size_t i = 1; i < info.Length(); ++i) {
+    const ObjcArgumentContext context = {
+        .className = std::string(object_getClassName(objcObject)),
+        .selectorName = selectorName,
+        .argumentIndex = (int)i - 1,
+    };
+    const char *typeEncoding =
+        SimplifyTypeEncoding([methodSignature getArgumentTypeAtIndex:i + 1]);
+    auto arg = AsObjCArgument(info[i], typeEncoding, context);
+    if (!arg.has_value()) {
+      std::string errorMessageStr = std::format("Unsupported argument type {}",
+                                                std::string(typeEncoding));
+      const char *errorMessage = errorMessageStr.c_str();
+      Napi::TypeError::New(env, errorMessage).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+    storedArgs.push_back(std::move(*arg));
+    std::visit(
+        [&](auto &&outer) {
+          using OuterT = std::decay_t<decltype(outer)>;
+          if constexpr (std::is_same_v<OuterT, BaseObjcType>) {
+            std::visit(SetObjCArgumentVisitor{invocation, i + 1}, outer);
+          } else if constexpr (std::is_same_v<OuterT, BaseObjcType *>) {
+            if (outer)
+              std::visit(SetObjCArgumentVisitor{invocation, i + 1}, *outer);
+          }
+        },
+        storedArgs.back());
+  }
+
+  [invocation invoke];
+  // storedArgs goes out of scope here, after invoke has completed
+  return ConvertReturnValueToJSValue(env, invocation, methodSignature);
+}
+
+Napi::Value ObjcObject::GetPointer(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  
+  // Get the pointer value of the Objective-C object
+  uintptr_t ptrValue = reinterpret_cast<uintptr_t>(objcObject);
+  
+  // Create a Buffer to hold the pointer (8 bytes on 64-bit macOS)
+  Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::New(env, sizeof(void*));
+  
+  // Write the pointer value to the buffer in little-endian format
+  uint8_t* data = buffer.Data();
+  for (size_t i = 0; i < sizeof(void*); ++i) {
+    data[i] = static_cast<uint8_t>((ptrValue >> (i * 8)) & 0xFF);
+  }
+  
+  return buffer;
+}

package/src/native/bridge.h

@@ -0,0 +1,391 @@
+#include "ObjcObject.h"
+#include <Foundation/Foundation.h>
+#include <format>
+#include <napi.h>
+#include <objc/objc.h>
+
+#ifndef NATIVE_BRIDGE_H
+#define NATIVE_BRIDGE_H
+
+// MARK: - Type Variant and Visitor
+
+using BaseObjcType = std::variant<char,               // c
+                                  int,                // i
+                                  short,              // s
+                                  long,               // l
+                                  long long,          // q
+                                  unsigned char,      // C
+                                  unsigned int,       // I
+                                  unsigned short,     // S
+                                  unsigned long,      // L
+                                  unsigned long long, // Q
+                                  float,              // f
+                                  double,             // d
+                                  bool,               // B
+                                  std::monostate,     // v (c type: void)
+                                  std::string,        // * (c type: char *)
+                                  id,                 // @
+                                  Class,              // #
+                                  SEL,                // :
+                                  void *              // ^ (pointer)
+                                  >;
+using ObjcType = std::variant<BaseObjcType, BaseObjcType *>;
+
+struct SetObjCArgumentVisitor {
+  NSInvocation *invocation;
+  size_t index;
+
+  void operator()(const std::string &str) const {
+    const char *cstr = str.c_str();
+    [invocation setArgument:&cstr atIndex:index];
+  }
+
+  void operator()(std::monostate) const {
+    // void type, do nothing.
+  }
+
+  void operator()(void *ptr) const {
+    [invocation setArgument:&ptr atIndex:index];
+  }
+
+  template <typename T> void operator()(T v) const {
+    [invocation setArgument:&v atIndex:index];
+  }
+};
+
+template <typename T1, typename T2> bool IsInRange(T1 value) {
+  static_assert(std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>,
+                "IsInRange<T1, T2>: both T1 and T2 must be arithmetic types");
+  long double v = static_cast<long double>(value);
+  long double lo = static_cast<long double>(std::numeric_limits<T2>::lowest());
+  long double hi = static_cast<long double>(std::numeric_limits<T2>::max());
+  return v >= lo && v <= hi;
+}
+
+// MARK: - Conversion Implementation
+
+struct ObjcArgumentContext {
+  std::string className;
+  std::string selectorName;
+  int argumentIndex;
+};
+
+#define CONVERT_ARG_ERROR_MSG(message)                                         \
+  std::format("Error converting argument {} of {} (on {}): {}",                \
+              context.argumentIndex, context.selectorName, context.className,  \
+              message)
+
+template <typename T>
+T ConvertJSNumberToNativeValue(const Napi::Value &value,
+                               const ObjcArgumentContext &context) {
+  static_assert(
+      std::is_arithmetic_v<T>,
+      "ConvertJSNumberToNativeValue<T>: T must be an arithmetic type");
+  if (!value.IsNumber()) {
+    throw Napi::TypeError::New(value.Env(),
+                               CONVERT_ARG_ERROR_MSG("Expected a number"));
+  }
+  double d = value.As<Napi::Number>().DoubleValue();
+  if (std::isnan(d)) {
+    throw Napi::TypeError::New(value.Env(),
+                               CONVERT_ARG_ERROR_MSG("Number cannot be NaN"));
+  }
+  if (std::isinf(d)) {
+    throw Napi::RangeError::New(
+        value.Env(), CONVERT_ARG_ERROR_MSG("Number cannot be infinite"));
+  }
+  if (!IsInRange<double, T>(d)) {
+    throw Napi::RangeError::New(
+        value.Env(), CONVERT_ARG_ERROR_MSG("Number is out of range"));
+  }
+  if constexpr (std::is_integral_v<T>) {
+    if (std::floor(d) != d) {
+      throw Napi::TypeError::New(
+          value.Env(), CONVERT_ARG_ERROR_MSG("Number must be an integer"));
+    }
+  }
+  return static_cast<T>(d);
+}
+
+template <typename T>
+T ConvertJSBigIntToNativeValue(const Napi::Value &value,
+                               const ObjcArgumentContext &context) {
+  static_assert(
+      std::is_arithmetic_v<T>,
+      "ConvertJSBigIntToNativeValue<T>: T must be an arithmetic type");
+  if (!value.IsBigInt()) {
+    throw Napi::TypeError::New(value.Env(),
+                               CONVERT_ARG_ERROR_MSG("Expected a BigInt"));
+  }
+  bool lossless = false;
+
+  if constexpr (std::is_integral_v<T>) {
+
+    if constexpr (std::is_unsigned_v<T>) {
+      uint64_t v = value.As<Napi::BigInt>().Uint64Value(&lossless);
+      if (!lossless) {
+        throw Napi::RangeError::New(
+            value.Env(),
+            CONVERT_ARG_ERROR_MSG(
+                "BigInt out of range for an unsigned 64-bit integer"));
+      }
+      if (!IsInRange<uint64_t, T>(v)) {
+        throw Napi::RangeError::New(
+            value.Env(), CONVERT_ARG_ERROR_MSG("BigInt out of range"));
+      }
+      return static_cast<T>(v);
+    } else if constexpr (std::is_signed_v<T>) {
+      int64_t v = value.As<Napi::BigInt>().Int64Value(&lossless);
+      if (!lossless) {
+        throw Napi::RangeError::New(
+            value.Env(),
+            CONVERT_ARG_ERROR_MSG(
+                "BigInt out of range for a signed 64-bit integer"));
+      }
+      if (!IsInRange<int64_t, T>(v)) {
+        throw Napi::RangeError::New(
+            value.Env(), CONVERT_ARG_ERROR_MSG("BigInt out of range"));
+      }
+      return static_cast<T>(v);
+    }
+  } else if constexpr (std::is_floating_point_v<T>) {
+    int64_t vs = value.As<Napi::BigInt>().Int64Value(&lossless);
+    if (lossless) {
+      return static_cast<T>(vs);
+    }
+    uint64_t vu = value.As<Napi::BigInt>().Uint64Value(&lossless);
+    if (lossless) {
+      if (!IsInRange<long double, T>(static_cast<long double>(vu))) {
+        throw Napi::RangeError::New(
+            value.Env(),
+            CONVERT_ARG_ERROR_MSG("BigInt too large for floating point value"));
+      }
+      return static_cast<T>(vu);
+    }
+    throw Napi::RangeError::New(
+        value.Env(),
+        CONVERT_ARG_ERROR_MSG("BigInt out of 64-bit representable range"));
+  }
+}
+
+template <typename T>
+T ConvertToNativeValue(const Napi::Value &value,
+                       const ObjcArgumentContext &context) {
+  if constexpr (std::is_same_v<T, id>) {
+    // is value an ObjcObject instance?
+    if (value.IsObject()) {
+      Napi::Object obj = value.As<Napi::Object>();
+      if (obj.InstanceOf(ObjcObject::constructor.Value())) {
+        ObjcObject *objcObj = Napi::ObjectWrap<ObjcObject>::Unwrap(obj);
+        return objcObj->objcObject;
+      }
+    }
+  }
+  if constexpr (std::is_same_v<T, SEL>) {
+    if (!value.IsString()) {
+      throw Napi::TypeError::New(value.Env(),
+                                 CONVERT_ARG_ERROR_MSG("Expected a string"));
+    }
+    std::string selName = value.As<Napi::String>().Utf8Value();
+    return sel_registerName(selName.c_str());
+  }
+  if constexpr (std::is_same_v<T, bool>) {
+    if (!value.IsBoolean()) {
+      throw Napi::TypeError::New(value.Env(),
+                                 CONVERT_ARG_ERROR_MSG("Expected a boolean"));
+    }
+    return value.As<Napi::Boolean>().Value();
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    if (!value.IsString()) {
+      throw Napi::TypeError::New(value.Env(),
+                                 CONVERT_ARG_ERROR_MSG("Expected a string"));
+    }
+    return value.As<Napi::String>().Utf8Value();
+  } else if constexpr (std::is_arithmetic_v<T>) {
+    if (value.IsNumber()) {
+      return ConvertJSNumberToNativeValue<T>(value, context);
+    } else if (value.IsBigInt()) {
+      return ConvertJSBigIntToNativeValue<T>(value, context);
+    } else {
+      throw Napi::TypeError::New(
+          value.Env(), CONVERT_ARG_ERROR_MSG("Expected a number or bigint"));
+    }
+  } else {
+    throw Napi::TypeError::New(
+        value.Env(), CONVERT_ARG_ERROR_MSG("Unsupported argument type"));
+  }
+}
+
+// MARK: - Conversion Top Layer
+
+// Helper class to manage the lifetime of simplified type encodings
+class SimplifiedTypeEncoding {
+private:
+  std::string simplified;
+
+public:
+  SimplifiedTypeEncoding(const char *typeEncoding) : simplified(typeEncoding) {
+    // Remove any leading qualifiers
+    while (!simplified.empty() && (simplified[0] == 'r' || simplified[0] == 'n' ||
+                                   simplified[0] == 'N' || simplified[0] == 'o' ||
+                                   simplified[0] == 'O' || simplified[0] == 'R' ||
+                                   simplified[0] == 'V')) {
+      simplified.erase(0, 1);
+    }
+  }
+
+  const char *c_str() const { return simplified.c_str(); }
+  char operator[](size_t index) const { return simplified[index]; }
+  operator const char *() const { return simplified.c_str(); }
+};
+
+// Legacy function for compatibility - returns pointer to internal string
+// WARNING: The returned pointer is only valid as long as the typeEncoding parameter is valid
+inline const char *SimplifyTypeEncoding(const char *typeEncoding) {
+  // For simple cases where there are no qualifiers, return the original pointer
+  if (typeEncoding && typeEncoding[0] != 'r' && typeEncoding[0] != 'n' &&
+      typeEncoding[0] != 'N' && typeEncoding[0] != 'o' &&
+      typeEncoding[0] != 'O' && typeEncoding[0] != 'R' &&
+      typeEncoding[0] != 'V') {
+    return typeEncoding;
+  }
+  
+  // For complex cases, we need to skip qualifiers
+  // This is a temporary fix - callers should use SimplifiedTypeEncoding class
+  static thread_local std::string buffer;
+  buffer = typeEncoding;
+  while (!buffer.empty() && (buffer[0] == 'r' || buffer[0] == 'n' ||
+                             buffer[0] == 'N' || buffer[0] == 'o' ||
+                             buffer[0] == 'O' || buffer[0] == 'R' ||
+                             buffer[0] == 'V')) {
+    buffer.erase(0, 1);
+  }
+  return buffer.c_str();
+}
+
+// Convert a Napi::Value to an ObjcType based on the provided type encoding.
+inline auto AsObjCArgument(const Napi::Value &value, const char *typeEncoding,
+                           const ObjcArgumentContext &context)
+    -> std::optional<ObjcType> {
+  const char *simplifiedTypeEncoding = SimplifyTypeEncoding(typeEncoding);
+  switch (*simplifiedTypeEncoding) {
+  case 'c':
+    return ConvertToNativeValue<char>(value, context);
+  case 'i':
+    return ConvertToNativeValue<int>(value, context);
+  case 's':
+    return ConvertToNativeValue<short>(value, context);
+  case 'l':
+    return ConvertToNativeValue<long>(value, context);
+  case 'q':
+    return ConvertToNativeValue<long long>(value, context);
+  case 'C':
+    return ConvertToNativeValue<unsigned char>(value, context);
+  case 'I':
+    return ConvertToNativeValue<unsigned int>(value, context);
+  case 'S':
+    return ConvertToNativeValue<unsigned short>(value, context);
+  case 'L':
+    return ConvertToNativeValue<unsigned long>(value, context);
+  case 'Q':
+    return ConvertToNativeValue<unsigned long long>(value, context);
+  case 'f':
+    return ConvertToNativeValue<float>(value, context);
+  case 'd':
+    return ConvertToNativeValue<double>(value, context);
+  case 'B':
+    return ConvertToNativeValue<bool>(value, context);
+  case '*':
+    return ConvertToNativeValue<std::string>(value, context);
+  case ':':
+    return ConvertToNativeValue<SEL>(value, context);
+  case '@':
+    return ConvertToNativeValue<id>(value, context);
+  case '^': // Pointer type (^v, ^c, etc.)
+    if (value.IsBuffer()) {
+      Napi::Buffer<uint8_t> buffer = value.As<Napi::Buffer<uint8_t>>();
+      return static_cast<void *>(buffer.Data());
+    }
+    if (value.IsTypedArray()) {
+      Napi::TypedArray typedArray = value.As<Napi::TypedArray>();
+      return static_cast<void *>(
+          reinterpret_cast<uint8_t *>(typedArray.ArrayBuffer().Data()) +
+          typedArray.ByteOffset());
+    }
+    if (value.IsNull() || value.IsUndefined()) {
+      return static_cast<void *>(nullptr);
+    }
+    return std::nullopt;
+  }
+  return std::nullopt;
+}
+
+// Convert the return value of an Objective-C method to a Napi::Value.
+inline Napi::Value
+ConvertReturnValueToJSValue(Napi::Env env, NSInvocation *invocation,
+                            NSMethodSignature *methodSignature) {
+#define NOBJC_NUMERIC_RETURN_CASE(encoding, ctype)                             \
+  case encoding: {                                                             \
+    ctype result;                                                              \
+    [invocation getReturnValue:&result];                                       \
+    return Napi::Number::New(env, result);                                     \
+  }
+  switch (*SimplifyTypeEncoding([methodSignature methodReturnType])) {
+    NOBJC_NUMERIC_RETURN_CASE('c', char)
+    NOBJC_NUMERIC_RETURN_CASE('i', int)
+    NOBJC_NUMERIC_RETURN_CASE('s', short)
+    NOBJC_NUMERIC_RETURN_CASE('l', long)
+    NOBJC_NUMERIC_RETURN_CASE('q', long long)
+    NOBJC_NUMERIC_RETURN_CASE('C', unsigned char)
+    NOBJC_NUMERIC_RETURN_CASE('I', unsigned int)
+    NOBJC_NUMERIC_RETURN_CASE('S', unsigned short)
+    NOBJC_NUMERIC_RETURN_CASE('L', unsigned long)
+    NOBJC_NUMERIC_RETURN_CASE('Q', unsigned long long)
+    NOBJC_NUMERIC_RETURN_CASE('f', float)
+    NOBJC_NUMERIC_RETURN_CASE('d', double)
+  case 'B': {
+    bool result;
+    [invocation getReturnValue:&result];
+    return Napi::Boolean::New(env, result);
+  }
+  case 'v':
+    return env.Undefined();
+  case '*': {
+    char *result = nullptr;
+    [invocation getReturnValue:&result];
+    if (result == nullptr) {
+      return env.Null();
+    }
+    Napi::String jsString = Napi::String::New(env, result);
+    // free(result); // It might not be safe to free this memory.
+    return jsString;
+  }
+  case '@':
+  case '#': {
+    id result = nil;
+    [invocation getReturnValue:&result];
+    if (result == nil) {
+      return env.Null();
+    }
+    return ObjcObject::NewInstance(env, result);
+  }
+  case ':': {
+    SEL result = nullptr;
+    [invocation getReturnValue:&result];
+    if (result == nullptr) {
+      return env.Null();
+    }
+    NSString *selectorString = NSStringFromSelector(result);
+    if (selectorString == nil) {
+      return env.Null();
+    }
+    return Napi::String::New(env, [selectorString UTF8String]);
+  }
+  default:
+    Napi::TypeError::New(env, "Unsupported return type (post-invoke)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+}
+
+#endif // NATIVE_BRIDGE_H