objc-js 0.0.12 → 0.0.14

package/src/native/method-forwarding.mm

@@ -1,4 +1,5 @@
 #include "method-forwarding.h"
+#include "debug.h"
 #include "ObjcObject.h"
 #include "protocol-storage.h"
 #include "type-conversion.h"
@@ -10,16 +11,20 @@
 // MARK: - ThreadSafeFunction Callback Handler
 
 // This function runs on the JavaScript thread
+// Handles both protocol implementation and subclass method forwarding
 void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
                     InvocationData *data) {
   if (!data) {
-    NSLog(@"Error: InvocationData is null in CallJSCallback");
+    NOBJC_ERROR("InvocationData is null in CallJSCallback");
     return;
   }
 
+  NOBJC_LOG("CallJSCallback: Called for selector %s, callbackType=%d", 
+            data->selectorName.c_str(), (int)data->callbackType);
+
   // Check if the callback is valid before proceeding
   if (jsCallback.IsEmpty()) {
-    NSLog(@"Error: jsCallback is null/empty in CallJSCallback for selector %s",
+    NOBJC_ERROR("jsCallback is null/empty in CallJSCallback for selector %s",
           data->selectorName.c_str());
     if (data->invocation) {
       [data->invocation release];
@@ -31,16 +36,18 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
 
   NSInvocation *invocation = data->invocation;
   if (!invocation) {
-    NSLog(@"Error: NSInvocation is null in CallJSCallback");
+    NOBJC_ERROR("NSInvocation is null in CallJSCallback");
     SignalInvocationComplete(data);
     delete data;
     return;
   }
 
+  NOBJC_LOG("CallJSCallback: About to get method signature");
+
   // Extract arguments using NSInvocation
   NSMethodSignature *sig = [invocation methodSignature];
   if (!sig) {
-    NSLog(@"Error: Failed to get method signature for selector %s",
+    NOBJC_ERROR("Failed to get method signature for selector %s",
           data->selectorName.c_str());
     SignalInvocationComplete(data);
     [invocation release];
@@ -48,42 +55,74 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
     return;
   }
 
+  NOBJC_LOG("CallJSCallback: Method signature: %s, numArgs: %lu", 
+            [sig description].UTF8String, (unsigned long)[sig numberOfArguments]);
+
   std::vector<napi_value> jsArgs;
 
-  // Skip first two arguments (self and _cmd)
+  // For subclass methods, include 'self' as first JavaScript argument
+  if (data->callbackType == CallbackType::Subclass) {
+    NOBJC_LOG("CallJSCallback: Extracting 'self' argument for subclass method");
+    __unsafe_unretained id selfObj;
+    [invocation getArgument:&selfObj atIndex:0];
+    NOBJC_LOG("CallJSCallback: About to create ObjcObject for self=%p", selfObj);
+    Napi::Value selfValue = ObjcObject::NewInstance(env, selfObj);
+    NOBJC_LOG("CallJSCallback: Created ObjcObject for self (JS wrapper created)");
+    jsArgs.push_back(selfValue);
+    NOBJC_LOG("CallJSCallback: Added self to jsArgs");
+  }
+
+  // Extract remaining arguments (skip self and _cmd, start at index 2)
+  NOBJC_LOG("CallJSCallback: Extracting %lu method arguments", (unsigned long)[sig numberOfArguments] - 2);
   for (NSUInteger i = 2; i < [sig numberOfArguments]; i++) {
     const char *type = [sig getArgumentTypeAtIndex:i];
     SimplifiedTypeEncoding argType(type);
+    
+    NOBJC_LOG("CallJSCallback: Processing arg %lu, type=%s, simplified=%s", 
+              (unsigned long)i, type, argType.c_str());
+    
+    // Handle out-parameters (e.g., NSError**) by passing null
+    // This avoids creating N-API Function objects which triggers Bun crashes
+    if (argType[0] == '^' && argType[1] == '@') {
+      NOBJC_LOG("CallJSCallback: Arg %lu is out-param (^@), passing null", (unsigned long)i);
+      jsArgs.push_back(env.Null());
+      continue;
+    }
+    
+    NOBJC_LOG("CallJSCallback: About to extract arg %lu to JS", (unsigned long)i);
     jsArgs.push_back(ExtractInvocationArgumentToJS(env, invocation, i, argType[0]));
+    NOBJC_LOG("CallJSCallback: Successfully extracted arg %lu", (unsigned long)i);
   }
 
   // Call the JavaScript callback
   try {
+    NOBJC_LOG("CallJSCallback: About to call JS function with %zu args", jsArgs.size());
     Napi::Value result = jsCallback.Call(jsArgs);
+    NOBJC_LOG("CallJSCallback: JS function returned successfully");
 
     // Handle return value if the method expects one
     const char *returnType = [sig methodReturnType];
     SimplifiedTypeEncoding retType(returnType);
 
     if (retType[0] != 'v') { // Not void
-      NSLog(@"Setting return value for %s, return type: %c",
-            data->selectorName.c_str(), retType[0]);
       SetInvocationReturnFromJS(invocation, result, retType[0],
                                 data->selectorName.c_str());
     }
   } catch (const Napi::Error &e) {
-    NSLog(@"Error calling JavaScript callback for %s: %s",
+    NOBJC_ERROR("Error calling JavaScript callback for %s: %s",
           data->selectorName.c_str(), e.what());
   } catch (const std::exception &e) {
-    NSLog(@"Exception calling JavaScript callback for %s: %s",
+    NOBJC_ERROR("Exception calling JavaScript callback for %s: %s",
           data->selectorName.c_str(), e.what());
   } catch (...) {
-    NSLog(@"Unknown error calling JavaScript callback for %s",
+    NOBJC_ERROR("Unknown error calling JavaScript callback for %s",
           data->selectorName.c_str());
   }
 
   // Signal completion to the waiting ForwardInvocation
+  NOBJC_LOG("CallJSCallback: About to signal completion for %s", data->selectorName.c_str());
   SignalInvocationComplete(data);
+  NOBJC_LOG("CallJSCallback: Signaled completion for %s", data->selectorName.c_str());
 
   // Clean up the invocation data
   // Release the invocation that we retained in ForwardInvocation
@@ -91,6 +130,46 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
   delete data;
 }
 
+// MARK: - Fallback Helper
+
+// Helper function to fallback to ThreadSafeFunction when direct call fails
+// This is used when direct JS callback invocation fails (e.g., in Electron)
+bool FallbackToTSFN(Napi::ThreadSafeFunction &tsfn, InvocationData *data,
+                    const std::string &selectorName) {
+  // Set up synchronization primitives
+  std::mutex completionMutex;
+  std::condition_variable completionCv;
+  bool isComplete = false;
+
+  data->completionMutex = &completionMutex;
+  data->completionCv = &completionCv;
+  data->isComplete = &isComplete;
+
+  // Call via ThreadSafeFunction
+  napi_status status = tsfn.NonBlockingCall(data, CallJSCallback);
+  tsfn.Release();
+
+  if (status != napi_ok) {
+    NOBJC_ERROR("FallbackToTSFN failed for selector %s (status: %d)",
+                selectorName.c_str(), status);
+    return false;
+  }
+
+  // Wait for callback by pumping CFRunLoop
+  CFTimeInterval timeout = 0.001; // 1ms per iteration
+  while (true) {
+    {
+      std::unique_lock<std::mutex> lock(completionMutex);
+      if (isComplete) {
+        break;
+      }
+    }
+    CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout, true);
+  }
+  
+  return true;
+}
+
 // MARK: - Message Forwarding Implementation
 
 // Override respondsToSelector to return YES for methods we implement
@@ -139,7 +218,7 @@ NSMethodSignature *MethodSignatureForSelector(id self, SEL _cmd, SEL selector) {
 // Handle forwarded invocations
 void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
   if (!invocation) {
-    NSLog(@"Error: ForwardInvocation called with nil invocation");
+    NOBJC_ERROR("ForwardInvocation called with nil invocation");
     return;
   }
 
@@ -151,7 +230,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
   SEL selector = [invocation selector];
   NSString *selectorString = NSStringFromSelector(selector);
   if (!selectorString) {
-    NSLog(@"Error: Failed to convert selector to string");
+    NOBJC_ERROR("Failed to convert selector to string");
     return;
   }
 
@@ -165,19 +244,18 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
   Napi::ThreadSafeFunction tsfn;
   std::string typeEncoding;
   pthread_t js_thread;
+  bool isElectron;
   {
     std::lock_guard<std::mutex> lock(g_implementations_mutex);
     auto it = g_implementations.find(ptr);
     if (it == g_implementations.end()) {
-      NSLog(@"Warning: Protocol implementation not found for instance %p",
-            self);
+      NOBJC_WARN("Protocol implementation not found for instance %p", self);
       return;
     }
 
     auto callbackIt = it->second.callbacks.find(selectorName);
     if (callbackIt == it->second.callbacks.end()) {
-      NSLog(@"Warning: Callback not found for selector %s",
-            selectorName.c_str());
+      NOBJC_WARN("Callback not found for selector %s", selectorName.c_str());
       return;
     }
 
@@ -188,7 +266,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
     tsfn = callbackIt->second;
     napi_status acq_status = tsfn.Acquire();
     if (acq_status != napi_ok) {
-      NSLog(@"Warning: Failed to acquire ThreadSafeFunction for selector %s",
+      NOBJC_WARN("Failed to acquire ThreadSafeFunction for selector %s",
             selectorName.c_str());
       return;
     }
@@ -201,6 +279,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
 
     // Get the JS thread ID to check if we're on the same thread
     js_thread = it->second.js_thread;
+    isElectron = it->second.isElectron;
   }
 
   // Check if we're on the JS thread
@@ -208,17 +287,20 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
 
   // IMPORTANT: We call directly on the JS thread so return values are set
   // synchronously; otherwise we use a ThreadSafeFunction to marshal work.
+  // EXCEPTION: In Electron, we ALWAYS use TSFN even on the JS thread because
+  // Electron's V8 context isn't properly set up for direct handle creation.
 
   // Create invocation data
   auto data = new InvocationData();
   data->invocation = invocation;
   data->selectorName = selectorName;
   data->typeEncoding = typeEncoding;
+  data->callbackType = CallbackType::Protocol;
 
   napi_status status;
 
-  if (is_js_thread) {
-    // We're on the JS thread (e.g., called from performSelector in Bun/Node)
+  if (is_js_thread && !isElectron) {
+    // We're on the JS thread in Node/Bun (NOT Electron)
     // Call directly to ensure return values are set synchronously.
     data->completionMutex = nullptr;
     data->completionCv = nullptr;
@@ -232,9 +314,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
       std::lock_guard<std::mutex> lock(g_implementations_mutex);
       auto it = g_implementations.find(ptr);
       if (it == g_implementations.end()) {
-        NSLog(@"Warning: Protocol implementation not found for instance %p "
-              @"(JS thread path)",
-              self);
+        NOBJC_WARN("Protocol implementation not found for instance %p (JS thread path)", self);
         [invocation release];
         delete data;
         return;
@@ -242,8 +322,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
 
       auto jsCallbackIt = it->second.jsCallbacks.find(selectorName);
       if (jsCallbackIt == it->second.jsCallbacks.end()) {
-        NSLog(@"Warning: JS callback not found for selector %s "
-              @"(JS thread path)",
+        NOBJC_WARN("JS callback not found for selector %s (JS thread path)",
               selectorName.c_str());
         [invocation release];
         delete data;
@@ -267,14 +346,11 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
       CallJSCallback(callEnv, jsFn, data);
       // CallJSCallback releases invocation and deletes data.
     } catch (const std::exception &e) {
-      NSLog(@"Error calling JS callback directly (likely invalid env in "
-            @"Electron): %s",
-            e.what());
-      NSLog(@"Falling back to ThreadSafeFunction for selector %s",
-            selectorName.c_str());
+      NOBJC_ERROR("Error calling JS callback directly (likely invalid env in Electron): %s", e.what());
+      NOBJC_LOG("Falling back to ThreadSafeFunction for selector %s", selectorName.c_str());
       
       // Fallback to TSFN if direct call fails (e.g., invalid env in Electron)
-      // We need to re-acquire the TSFN and set up sync primitives
+      // We need to re-acquire the TSFN
       {
         std::lock_guard<std::mutex> lock(g_implementations_mutex);
         auto it = g_implementations.find(ptr);
@@ -284,30 +360,8 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
             tsfn = callbackIt->second;
             napi_status acq_status = tsfn.Acquire();
             if (acq_status == napi_ok) {
-              // Set up synchronization for fallback path
-              std::mutex completionMutex;
-              std::condition_variable completionCv;
-              bool isComplete = false;
-
-              data->completionMutex = &completionMutex;
-              data->completionCv = &completionCv;
-              data->isComplete = &isComplete;
-
-              status = tsfn.NonBlockingCall(data, CallJSCallback);
-              tsfn.Release();
-
-              if (status == napi_ok) {
-                // Wait for callback by pumping CFRunLoop
-                CFTimeInterval timeout = 0.001; // 1ms per iteration
-                while (true) {
-                  {
-                    std::unique_lock<std::mutex> lock(completionMutex);
-                    if (isComplete) {
-                      break;
-                    }
-                  }
-                  CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout, true);
-                }
+              // Use helper function for fallback
+              if (FallbackToTSFN(tsfn, data, selectorName)) {
                 return; // Data cleaned up in callback
               }
             }
@@ -335,8 +389,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
     tsfn.Release();
 
     if (status != napi_ok) {
-      NSLog(@"Error: Failed to call ThreadSafeFunction for selector %s "
-            @"(status: %d)",
+      NOBJC_ERROR("Failed to call ThreadSafeFunction for selector %s (status: %d)",
             selectorName.c_str(), status);
       [invocation release];
       delete data;
@@ -382,8 +435,7 @@ void DeallocImplementation(id self, SEL _cmd) {
         it->second.typeEncodings.clear();
       } catch (...) {
         // Ignore errors during cleanup
-        NSLog(@"Warning: Exception during callback cleanup for instance %p",
-              self);
+        NOBJC_WARN("Exception during callback cleanup for instance %p", self);
       }
       g_implementations.erase(it);
     }

package/src/native/nobjc.mm

@@ -1,5 +1,6 @@
 #include "ObjcObject.h"
 #include "protocol-impl.h"
+#include "subclass-impl.h"
 #include <Foundation/Foundation.h>
 #include <dlfcn.h>
 #include <napi.h>
@@ -107,6 +108,8 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
   exports.Set("FromPointer", Napi::Function::New(env, FromPointer));
   exports.Set("CreateProtocolImplementation",
               Napi::Function::New(env, CreateProtocolImplementation));
+  exports.Set("DefineClass", Napi::Function::New(env, DefineClass));
+  exports.Set("CallSuper", Napi::Function::New(env, CallSuper));
   return exports;
 }
 

package/src/native/protocol-impl.mm

@@ -1,4 +1,5 @@
 #include "protocol-impl.h"
+#include "debug.h"
 #include "method-forwarding.h"
 #include "ObjcObject.h"
 #include "protocol-storage.h"
@@ -103,8 +104,7 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
     protocol = objc_getProtocol(protocolName.c_str());
     if (protocol == nullptr) {
       // Log warning but continue (for informal protocols)
-      NSLog(@"Warning: Protocol %s not found, creating class without protocol "
-            @"conformance",
+      NOBJC_WARN("Protocol %s not found, creating class without protocol conformance",
             protocolName.c_str());
     }
   }
@@ -130,13 +130,33 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
   // Get the method implementations object's property names
   Napi::Array propertyNames = methodImplementations.GetPropertyNames();
 
+  // Detect if we're running in Electron by checking process.versions.electron
+  bool isElectron = false;
+  try {
+    Napi::Object global = env.Global();
+    if (global.Has("process")) {
+      Napi::Object process = global.Get("process").As<Napi::Object>();
+      if (process.Has("versions")) {
+        Napi::Object versions = process.Get("versions").As<Napi::Object>();
+        isElectron = versions.Has("electron");
+      }
+    }
+  } catch (...) {
+    // If detection fails, assume not Electron
+  }
+  
+  if (isElectron) {
+    // Electron runtime detected, will always use TSFN path
+  }
+
   // Store callbacks for this instance (we'll set the instance pointer later)
   ProtocolImplementation impl{
       .callbacks = {},
       .typeEncodings = {},
       .className = className,
       .env = env,
-      .js_thread = pthread_self() // Store the current (JS) thread ID
+      .js_thread = pthread_self(), // Store the current (JS) thread ID
+      .isElectron = isElectron
   };
 
   // Store default type encodings to keep them alive
@@ -153,7 +173,7 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
     Napi::Value value = methodImplementations.Get(key);
 
     if (!value.IsFunction()) {
-      NSLog(@"Warning: Value for selector %s is not a function, skipping",
+      NOBJC_WARN("Value for selector %s is not a function, skipping",
             selectorName.c_str());
       continue;
     }
@@ -198,8 +218,7 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
       defaultTypeEncodings.push_back(std::move(defaultEncoding));
       typeEncoding = defaultTypeEncodings.back().c_str();
 
-      NSLog(@"Warning: No type encoding found for selector %s, using default: "
-            @"%s",
+      NOBJC_WARN("No type encoding found for selector %s, using default: %s",
             selectorName.c_str(), typeEncoding);
     }
 
@@ -224,7 +243,7 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
   // methods yet
   if (!class_addMethod(newClass, @selector(respondsToSelector:),
                        (IMP)RespondsToSelector, "B@::")) {
-    NSLog(@"Warning: Failed to add respondsToSelector: method");
+    NOBJC_WARN("Failed to add respondsToSelector: method");
   }
 
   // Add message forwarding methods to the class

package/src/native/protocol-storage.h

@@ -13,20 +13,33 @@
 @class NSInvocation;
 #else
 typedef struct NSInvocation NSInvocation;
+typedef struct objc_class *Class;
 #endif
 
 // MARK: - Data Structures
 
+// Callback type for method forwarding
+enum class CallbackType {
+  Protocol,  // Protocol implementation - args start at index 2
+  Subclass   // Subclass override - include self at index 0 as first JS arg
+};
+
 // Data passed from native thread to JS thread for invocation handling
 struct InvocationData {
   NSInvocation *invocation;
   std::string selectorName;
   std::string typeEncoding;
+  // Type of callback (protocol or subclass)
+  CallbackType callbackType;
   // Synchronization: we use NonBlockingCall + runloop pumping to avoid
   // deadlocks in Electron while still getting return values
   std::mutex *completionMutex;
   std::condition_variable *completionCv;
   bool *isComplete;
+  // For subclass method calls: the instance pointer (for super calls)
+  void *instancePtr;
+  // For subclass method calls: the superclass for super calls
+  void *superClassPtr;
 };
 
 // Stores information about a protocol implementation instance
@@ -43,6 +56,37 @@ struct ProtocolImplementation {
   napi_env env;
   // Store the JS thread ID for thread detection
   pthread_t js_thread;
+  // Flag to indicate if running in Electron (requires TSFN path always)
+  bool isElectron;
+};
+
+// MARK: - Subclass Storage
+
+// Information about an overridden method in a subclass
+struct SubclassMethodInfo {
+  Napi::ThreadSafeFunction callback;
+  Napi::FunctionReference jsCallback;
+  std::string typeEncoding;
+  std::string selectorName;
+  bool isClassMethod;
+};
+
+// Stores information about a JS-defined subclass
+struct SubclassImplementation {
+  // Class name
+  std::string className;
+  // The Objective-C Class object
+  void *objcClass;       // Class
+  // The superclass for super calls
+  void *superClass;      // Class
+  // Methods defined by JS (selector -> info)
+  std::unordered_map<std::string, SubclassMethodInfo> methods;
+  // Store the environment for direct calls
+  napi_env env;
+  // Store the JS thread ID for thread detection
+  pthread_t js_thread;
+  // Flag to indicate if running in Electron
+  bool isElectron;
 };
 
 // MARK: - Global Storage
@@ -53,6 +97,11 @@ struct ProtocolImplementation {
 extern std::unordered_map<void *, ProtocolImplementation> g_implementations;
 extern std::mutex g_implementations_mutex;
 
+// Global map: Class pointer -> subclass implementation details
+// This stores information about JS-defined subclasses
+extern std::unordered_map<void *, SubclassImplementation> g_subclasses;
+extern std::mutex g_subclasses_mutex;
+
 // MARK: - Storage Access Helpers
 
 // Helper to signal completion of an invocation
@@ -76,5 +125,17 @@ FindImplementation(void *instancePtr) {
   return nullptr;
 }
 
+// Look up subclass implementation for a Class pointer
+// Returns nullptr if not found
+// Caller must hold g_subclasses_mutex
+inline SubclassImplementation *
+FindSubclassImplementation(void *classPtr) {
+  auto it = g_subclasses.find(classPtr);
+  if (it != g_subclasses.end()) {
+    return &it->second;
+  }
+  return nullptr;
+}
+
 #endif // PROTOCOL_STORAGE_H
 

package/src/native/subclass-impl.h

@@ -0,0 +1,20 @@
+#ifndef SUBCLASS_IMPL_H
+#define SUBCLASS_IMPL_H
+
+#include <napi.h>
+
+// Define a new Objective-C class at runtime from JavaScript
+// Arguments: { name: string, superclass: string|Class, protocols?: string[], methods?: {...} }
+// Returns: The new Class object
+Napi::Value DefineClass(const Napi::CallbackInfo &info);
+
+// Call the superclass implementation of a method
+// Arguments: self, selectorName, ...args
+// Returns: The result of the super call
+Napi::Value CallSuper(const Napi::CallbackInfo &info);
+
+// Callback handler for subclass methods (called from JS thread)
+void CallSubclassJSCallback(Napi::Env env, Napi::Function jsCallback,
+                            struct InvocationData *data);
+
+#endif // SUBCLASS_IMPL_H