objc-js 0.0.15 → 1.0.1

package/src/native/protocol-manager.h

@@ -0,0 +1,145 @@
+#ifndef PROTOCOL_MANAGER_H
+#define PROTOCOL_MANAGER_H
+
+/**
+ * @file protocol-manager.h
+ * @brief Singleton manager for protocol implementations.
+ *
+ * ProtocolManager provides thread-safe access to protocol implementation storage.
+ * It replaces the global g_implementations map and g_implementations_mutex with
+ * an encapsulated singleton pattern.
+ *
+ * Usage:
+ *   // Register a protocol implementation
+ *   ProtocolManager::Instance().Register(instancePtr, std::move(impl));
+ *
+ *   // Find an implementation
+ *   auto* impl = ProtocolManager::Instance().Find(instancePtr);
+ *
+ *   // Execute a callback with lock held
+ *   ProtocolManager::Instance().WithLock([](auto& map) {
+ *     // ... work with map ...
+ *   });
+ */
+
+#include "protocol-storage.h"
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <unordered_map>
+
+namespace nobjc {
+
+/**
+ * @brief Thread-safe singleton manager for protocol implementations.
+ *
+ * Encapsulates storage and synchronization for protocol implementations,
+ * providing a clean API for registration, lookup, and unregistration.
+ */
+class ProtocolManager {
+public:
+  /**
+   * @brief Get the singleton instance.
+   * @return Reference to the singleton ProtocolManager.
+   */
+  static ProtocolManager& Instance() {
+    static ProtocolManager instance;
+    return instance;
+  }
+
+  // Delete copy/move operations for singleton
+  ProtocolManager(const ProtocolManager&) = delete;
+  ProtocolManager& operator=(const ProtocolManager&) = delete;
+  ProtocolManager(ProtocolManager&&) = delete;
+  ProtocolManager& operator=(ProtocolManager&&) = delete;
+
+  /**
+   * @brief Find an implementation by instance pointer.
+   * @param instancePtr The Objective-C instance pointer (bridged from id).
+   * @return Pointer to implementation if found, nullptr otherwise.
+   * @note Caller must NOT hold the lock. This method acquires the lock.
+   */
+  ProtocolImplementation* Find(void* instancePtr) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = implementations_.find(instancePtr);
+    if (it != implementations_.end()) {
+      return &it->second;
+    }
+    return nullptr;
+  }
+
+  /**
+   * @brief Register a new protocol implementation.
+   * @param instancePtr The Objective-C instance pointer.
+   * @param impl The implementation to register (moved).
+   */
+  void Register(void* instancePtr, ProtocolImplementation&& impl) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    implementations_.emplace(instancePtr, std::move(impl));
+  }
+
+  /**
+   * @brief Unregister a protocol implementation.
+   * @param instancePtr The Objective-C instance pointer.
+   * @return true if the implementation was found and removed, false otherwise.
+   */
+  bool Unregister(void* instancePtr) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return implementations_.erase(instancePtr) > 0;
+  }
+
+  /**
+   * @brief Execute a callback with the lock held.
+   * @param callback Function to call with the map reference.
+   *
+   * Use this for complex operations that need to access multiple map entries
+   * or perform conditional logic while holding the lock.
+   */
+  template <typename Callback>
+  auto WithLock(Callback&& callback)
+      -> decltype(callback(std::declval<std::unordered_map<void*, ProtocolImplementation>&>())) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return callback(implementations_);
+  }
+
+  /**
+   * @brief Execute a read-only callback with the lock held.
+   * @param callback Function to call with const map reference.
+   */
+  template <typename Callback>
+  auto WithLockConst(Callback&& callback) const
+      -> decltype(callback(std::declval<const std::unordered_map<void*, ProtocolImplementation>&>())) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return callback(implementations_);
+  }
+
+  /**
+   * @brief Get the number of registered implementations.
+   * @return Count of implementations.
+   */
+  size_t Size() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return implementations_.size();
+  }
+
+  /**
+   * @brief Check if an implementation exists for the given pointer.
+   * @param instancePtr The Objective-C instance pointer.
+   * @return true if registered, false otherwise.
+   */
+  bool Contains(void* instancePtr) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return implementations_.find(instancePtr) != implementations_.end();
+  }
+
+private:
+  ProtocolManager() = default;
+  ~ProtocolManager() = default;
+
+  mutable std::mutex mutex_;
+  std::unordered_map<void*, ProtocolImplementation> implementations_;
+};
+
+} // namespace nobjc
+
+#endif // PROTOCOL_MANAGER_H

package/src/native/protocol-storage.h

@@ -89,18 +89,15 @@ struct SubclassImplementation {
   bool isElectron;
 };
 
-// MARK: - Global Storage
+// MARK: - Global Storage (DEPRECATED - use ProtocolManager/SubclassManager instead)
+// These declarations are kept for backward compatibility during migration.
+// New code should use:
+//   - nobjc::ProtocolManager::Instance() for protocol implementations
+//   - nobjc::SubclassManager::Instance() for subclass implementations
 
-// Global map: instance pointer -> implementation details
-// This keeps JavaScript callbacks alive for the lifetime of the Objective-C
-// object
-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;
+// Note: These extern declarations are removed as storage is now in the manager singletons.
+// If you need to access the storage, use the manager classes directly.
+// See protocol-manager.h and subclass-manager.h for the new APIs.
 
 // MARK: - Storage Access Helpers
 
@@ -113,29 +110,11 @@ inline void SignalInvocationComplete(InvocationData *data) {
   }
 }
 
-// Look up implementation for an instance pointer
-// Returns nullptr if not found
-// Caller must hold g_implementations_mutex
-inline ProtocolImplementation *
-FindImplementation(void *instancePtr) {
-  auto it = g_implementations.find(instancePtr);
-  if (it != g_implementations.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
+// DEPRECATED: Use nobjc::ProtocolManager::Instance().Find(instancePtr) instead
+// This function is no longer available as global storage has been moved to manager classes.
 
-// 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;
-}
+// DEPRECATED: Use nobjc::SubclassManager::Instance().Find(classPtr) instead
+// This function is no longer available as global storage has been moved to manager classes.
 
 #endif // PROTOCOL_STORAGE_H
 

package/src/native/runtime-detection.h

@@ -0,0 +1,54 @@
+#ifndef RUNTIME_DETECTION_H
+#define RUNTIME_DETECTION_H
+
+#include <napi.h>
+
+/**
+ * Detects if the code is running in an Electron environment.
+ *
+ * This is detected by checking for process.versions.electron.
+ * In Electron, direct JS callback invocation may fail due to V8 context
+ * issues, so we need to use ThreadSafeFunction for all callbacks.
+ *
+ * @param env The N-API environment
+ * @return true if running in Electron, false otherwise
+ */
+inline bool IsElectronRuntime(Napi::Env env) {
+  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>();
+        return versions.Has("electron");
+      }
+    }
+  } catch (...) {
+    // If detection fails, assume not Electron
+  }
+  return false;
+}
+
+/**
+ * Detects if the code is running in Bun.
+ *
+ * @param env The N-API environment
+ * @return true if running in Bun, false otherwise
+ */
+inline bool IsBunRuntime(Napi::Env env) {
+  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>();
+        return versions.Has("bun");
+      }
+    }
+  } catch (...) {
+    // If detection fails, assume not Bun
+  }
+  return false;
+}
+
+#endif // RUNTIME_DETECTION_H