plusui-native-core 0.1.105 → 0.1.106

package/Core/include/plusui/connect.hpp

@@ -1,11 +1,11 @@
-#pragma once
-
-#include <functional>
-#include <map>
-#include <nlohmann/json.hpp>
-#include <string>
-#include <vector>
-
+#pragma once
+
+#include <functional>
+#include <map>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
 // ============================================================================
 // PlusUI Connect
 // ============================================================================
@@ -69,335 +69,335 @@
 //    connect::settings.onSetTheme = [](json) { ... }; connect::settings.themeChange({{...}});
 //
 // ============================================================================
-
-namespace plusui {
-
-class Window;
-
-class Connect {
-public:
-  using EventHandler = std::function<void(const nlohmann::json &)>;
-  using CallHandler =
-      std::function<nlohmann::json(const nlohmann::json &)>;
-  using SubscriptionHandler =
-      std::function<void(bool subscribed, const nlohmann::json &)>;
-
-  class Feature {
-    Connect *owner;
-    std::string scope;
-
-    std::string scopedName(const std::string &name) const {
-      const std::string prefix = scope + ".";
-      if (name.rfind(prefix, 0) == 0) {
-        return name;
-      }
-      return prefix + name;
-    }
-
-  public:
-    Feature(Connect *parent, std::string featureScope)
-        : owner(parent), scope(std::move(featureScope)) {}
-
-    void on(const std::string &name, EventHandler handler) {
-      owner->on(scopedName(name), std::move(handler));
-    }
-
-    void emit(const std::string &name, const nlohmann::json &payload) {
-      owner->emit(scopedName(name), payload);
-    }
-
-    void onCall(const std::string &name, CallHandler handler) {
-      owner->onCall(scopedName(name), std::move(handler));
-    }
-
-    void onSubscription(const std::string &name,
-                        SubscriptionHandler handler) {
-      owner->onSubscription(scopedName(name), std::move(handler));
-    }
-  };
-
-  // ============================================================
-  // Channel — single-name channel object (legacy / backward compat)
-  //
-  // Mirror of the TypeScript createChannel() object:
-  //   download.on([](const json& p) { ... });
-  //   download.emit({{"progress", 50}});
-  //
-  // Obtained via connect.channel("download") or declared in
-  // the auto-generated connections.gen.hpp.
-  // ============================================================
-  class Channel {
-    Connect *owner;
-    std::string name_;
-
-  public:
-    Channel() : owner(nullptr) {}
-    Channel(Connect *parent, std::string channelName)
-        : owner(parent), name_(std::move(channelName)) {}
-
-    // Register a listener — mirrors TypeScript: download.on((d) => { ... })
-    void on(EventHandler handler) {
-      if (owner) owner->on(name_, std::move(handler));
-    }
-
-    // Send a message — mirrors TypeScript: download.emit({ key: value })
-    void emit(const nlohmann::json &payload = nlohmann::json::object()) {
-      if (owner) owner->emit(name_, payload);
-    }
-
-    const std::string &name() const { return name_; }
-  };
-
-private:
-  std::function<void(const std::string &)> outboundHandler;
-  std::map<std::string, std::vector<EventHandler>> eventHandlers;
-  std::map<std::string, CallHandler> callHandlers;
-  std::map<std::string, SubscriptionHandler> subscriptionHandlers;
-
-  void emitEnvelope(const std::string &kind, const std::string &name,
-                    const nlohmann::json &payload,
-                    const std::string &id = std::string(),
-                    const std::string &error = std::string()) {
-    if (!outboundHandler) {
-      return;
-    }
-
-    nlohmann::json j;
-    j["kind"] = kind;
-    j["name"] = name;
-    if (!id.empty()) {
-      j["id"] = id;
-    }
-    j["payload"] = payload;
-    if (!error.empty()) {
-      j["error"] = error;
-    }
-
-    outboundHandler(j.dump());
-  }
-
-public:
-
-  virtual ~Connect() = default;
-
-  // Mirror frontend API: register message listener by name
-  void on(const std::string &name, EventHandler handler) {
-    eventHandlers[name].push_back(std::move(handler));
-  }
-
-  Feature feature(const std::string &scope) { return Feature(this, scope); }
-
-  // Create a named channel object — mirrors TypeScript createChannel('name')
-  Channel channel(const std::string &name) { return Channel(this, name); }
-
-  // Request/response helper for call primitive
-  void onCall(const std::string &name, CallHandler handler) {
-    callHandlers[name] = std::move(handler);
-  }
-
-  // Subscription helper for stream/query primitives
-  void onSubscription(const std::string &name, SubscriptionHandler handler) {
-    subscriptionHandlers[name] = std::move(handler);
-  }
-
-  // Setup the outbound message handler
-  void setOutbound(std::function<void(const std::string &)> h) {
-    outboundHandler = std::move(h);
-  }
-
-  void setOutboundHandler(std::function<void(const std::string &)> h) {
-    setOutbound(std::move(h));
-  }
-
-  /**
-   * emit() - Send a message to the frontend
-   *
-   * Works for all 5 communication patterns:
-   *   - SIMPLEX: emit("notification", {{"msg", "Hi!"}})
-   *   - CALL RESPONSE: emitResult(id, name, payload)
-   *   - STREAM/PUB-SUB: emit("updates", {{"value", x}})  // call repeatedly
-   *   - STATE: emit("theme", {{"mode", "dark"}})
-   */
-  void emit(const std::string &name, const nlohmann::json &payload) {
-    emitEnvelope("event", name, payload);
-  }
-
-  void emitResult(const std::string &id, const std::string &name,
-                  const nlohmann::json &payload) {
-    emitEnvelope("result", name, payload, id);
-  }
-
-  void emitError(const std::string &id, const std::string &name,
-                 const std::string &message) {
-    emitEnvelope("error", name, nlohmann::json::object(), id, message);
-  }
-
-  /**
-   * call() - Make a call to the frontend and wait for response
-   *
-   * Enables bidirectional request/response:
-   *   Backend: auto answer = connect.call("ui.promptUser", {{"msg", "Sure?"}});
-   *   Frontend: connect.ui.handlePromptUser = async (data) => { ... return result; };
-   */
-  void call(const std::string &name, const nlohmann::json &payload,
-            std::function<void(const nlohmann::json &)> onResult = nullptr,
-            std::function<void(const std::string &)> onError = nullptr) {
-    auto id = std::to_string(std::chrono::steady_clock::now().time_since_epoch().count());
-    
-    if (onResult || onError) {
-      // Store pending callback for when frontend responds
-      on(name + ".__result__." + id, [this, id, name, onResult, onError](const nlohmann::json &p) {
-        if (p.contains("error") && onError) {
-          onError(p["error"].get<std::string>());
-        } else if (onResult) {
-          onResult(p.value("payload", nlohmann::json::object()));
-        }
-      });
-    }
-
-    emitEnvelope("call", name, payload, id);
-  }
-
-  // Parse and dispatch incoming messages from frontend
-  void dispatchMessage(const std::string &message) {
-    try {
-      auto j = nlohmann::json::parse(message);
-      nlohmann::json envelope = j;
-
-      if (j.is_object() && j.value("method", std::string()) ==
-                               "connection.dispatch") {
-        auto paramsIt = j.find("params");
-        if (paramsIt != j.end() && paramsIt->is_array() &&
-            !paramsIt->empty() && (*paramsIt)[0].is_object()) {
-          envelope = (*paramsIt)[0];
-        }
-      }
-
-      std::string name = envelope.value("name", "");
-      nlohmann::json payload =
-          envelope.value("payload", nlohmann::json::object());
-      std::string kind = envelope.value("kind", "fire");
-      std::string id = envelope.value("id", "");
-      
-      if (name.empty()) {
-        return;
-      }
-
-      if (kind == "call") {
-        try {
-          nlohmann::json responsePayload = nlohmann::json::object();
-          auto callIt = callHandlers.find(name);
-          if (callIt != callHandlers.end()) {
-            responsePayload = callIt->second(payload);
-          } else {
-            responsePayload = handleCall(name, payload);
-          }
-          if (!id.empty()) {
-            emitResult(id, name, responsePayload);
-          }
-        } catch (const std::exception &e) {
-          if (!id.empty()) {
-            emitError(id, name, e.what());
-          }
-        } catch (...) {
-          if (!id.empty()) {
-            emitError(id, name, "Unknown error");
-          }
-        }
-        return;
-      }
-
-      if (kind == "result" || kind == "error") {
-        // Response from a frontend call — dispatch to pending listeners
-        std::string resultKey = name + ".__result__." + id;
-        auto listenersIt = eventHandlers.find(resultKey);
-        if (listenersIt != eventHandlers.end()) {
-          nlohmann::json resultPayload;
-          if (kind == "error") {
-            resultPayload["error"] = envelope.value("error", "Unknown error");
-          } else {
-            resultPayload["payload"] = payload;
-          }
-          for (const auto &listener : listenersIt->second) {
-            listener(resultPayload);
-          }
-          eventHandlers.erase(resultKey);
-        }
-        return;
-      }
-
-      if (kind == "sub") {
-        auto subIt = subscriptionHandlers.find(name);
-        if (subIt != subscriptionHandlers.end()) {
-          subIt->second(true, payload);
-        }
-        handleSubscription(name, true, payload);
-        return;
-      }
-
-      if (kind == "unsub") {
-        auto subIt = subscriptionHandlers.find(name);
-        if (subIt != subscriptionHandlers.end()) {
-          subIt->second(false, payload);
-        }
-        handleSubscription(name, false, payload);
-        return;
-      }
-
-      auto listenersIt = eventHandlers.find(name);
-      if (listenersIt != eventHandlers.end()) {
-        for (const auto &listener : listenersIt->second) {
-          listener(payload);
-        }
-      }
-
-      handleMessage(name, payload);
-    } catch (...) {
-      // Silently ignore malformed messages
-    }
-  }
-
-  void dispatch(const std::string &message) { dispatchMessage(message); }
-
-protected:
-  virtual nlohmann::json handleCall(const std::string &name,
-                                    const nlohmann::json &payload) {
-    handleMessage(name, payload);
-    return nlohmann::json::object();
-  }
-
-  virtual void handleSubscription(const std::string &name, bool subscribed,
-                                  const nlohmann::json &payload) {
-    (void)name;
-    (void)subscribed;
-    (void)payload;
-  }
-
-  /**
-   * handleMessage() - Receive messages from the frontend
-   *
-   * Override this to handle incoming messages. This is your "on()" equivalent.
-   *
-   * For the new semantic API, prefer using the generated connect:: namespace
-   * instead of overriding this method:
-   *
-   *   connect::user.handleFetch = [](const json& p) -> json {
-   *     return database.getUser(p["id"]);
-   *   };
-   *
-   * This method remains for backward compatibility and catch-all handling.
-   */
-  virtual void handleMessage(const std::string &name,
-                             const nlohmann::json &payload) {
-    (void)name;
-    (void)payload;
-  }
-};
-
-void bindConnect(Window &window, Connect &connect);
-
-// Legacy aliases for backwards compatibility
-using Bridge = Connect;
-using Connection = Connect;
-
-} // namespace plusui
+
+namespace plusui {
+
+class Window;
+
+class Connect {
+public:
+  using EventHandler = std::function<void(const nlohmann::json &)>;
+  using CallHandler =
+      std::function<nlohmann::json(const nlohmann::json &)>;
+  using SubscriptionHandler =
+      std::function<void(bool subscribed, const nlohmann::json &)>;
+
+  class Feature {
+    Connect *owner;
+    std::string scope;
+
+    std::string scopedName(const std::string &name) const {
+      const std::string prefix = scope + ".";
+      if (name.rfind(prefix, 0) == 0) {
+        return name;
+      }
+      return prefix + name;
+    }
+
+  public:
+    Feature(Connect *parent, std::string featureScope)
+        : owner(parent), scope(std::move(featureScope)) {}
+
+    void on(const std::string &name, EventHandler handler) {
+      owner->on(scopedName(name), std::move(handler));
+    }
+
+    void emit(const std::string &name, const nlohmann::json &payload) {
+      owner->emit(scopedName(name), payload);
+    }
+
+    void onCall(const std::string &name, CallHandler handler) {
+      owner->onCall(scopedName(name), std::move(handler));
+    }
+
+    void onSubscription(const std::string &name,
+                        SubscriptionHandler handler) {
+      owner->onSubscription(scopedName(name), std::move(handler));
+    }
+  };
+
+  // ============================================================
+  // Channel — single-name channel object (legacy / backward compat)
+  //
+  // Mirror of the TypeScript createChannel() object:
+  //   download.on([](const json& p) { ... });
+  //   download.emit({{"progress", 50}});
+  //
+  // Obtained via connect.channel("download") or declared in
+  // the auto-generated connections.gen.hpp.
+  // ============================================================
+  class Channel {
+    Connect *owner;
+    std::string name_;
+
+  public:
+    Channel() : owner(nullptr) {}
+    Channel(Connect *parent, std::string channelName)
+        : owner(parent), name_(std::move(channelName)) {}
+
+    // Register a listener — mirrors TypeScript: download.on((d) => { ... })
+    void on(EventHandler handler) {
+      if (owner) owner->on(name_, std::move(handler));
+    }
+
+    // Send a message — mirrors TypeScript: download.emit({ key: value })
+    void emit(const nlohmann::json &payload = nlohmann::json::object()) {
+      if (owner) owner->emit(name_, payload);
+    }
+
+    const std::string &name() const { return name_; }
+  };
+
+private:
+  std::function<void(const std::string &)> outboundHandler;
+  std::map<std::string, std::vector<EventHandler>> eventHandlers;
+  std::map<std::string, CallHandler> callHandlers;
+  std::map<std::string, SubscriptionHandler> subscriptionHandlers;
+
+  void emitEnvelope(const std::string &kind, const std::string &name,
+                    const nlohmann::json &payload,
+                    const std::string &id = std::string(),
+                    const std::string &error = std::string()) {
+    if (!outboundHandler) {
+      return;
+    }
+
+    nlohmann::json j;
+    j["kind"] = kind;
+    j["name"] = name;
+    if (!id.empty()) {
+      j["id"] = id;
+    }
+    j["payload"] = payload;
+    if (!error.empty()) {
+      j["error"] = error;
+    }
+
+    outboundHandler(j.dump());
+  }
+
+public:
+
+  virtual ~Connect() = default;
+
+  // Mirror frontend API: register message listener by name
+  void on(const std::string &name, EventHandler handler) {
+    eventHandlers[name].push_back(std::move(handler));
+  }
+
+  Feature feature(const std::string &scope) { return Feature(this, scope); }
+
+  // Create a named channel object — mirrors TypeScript createChannel('name')
+  Channel channel(const std::string &name) { return Channel(this, name); }
+
+  // Request/response helper for call primitive
+  void onCall(const std::string &name, CallHandler handler) {
+    callHandlers[name] = std::move(handler);
+  }
+
+  // Subscription helper for stream/query primitives
+  void onSubscription(const std::string &name, SubscriptionHandler handler) {
+    subscriptionHandlers[name] = std::move(handler);
+  }
+
+  // Setup the outbound message handler
+  void setOutbound(std::function<void(const std::string &)> h) {
+    outboundHandler = std::move(h);
+  }
+
+  void setOutboundHandler(std::function<void(const std::string &)> h) {
+    setOutbound(std::move(h));
+  }
+
+  /**
+   * emit() - Send a message to the frontend
+   *
+   * Works for all 5 communication patterns:
+   *   - SIMPLEX: emit("notification", {{"msg", "Hi!"}})
+   *   - CALL RESPONSE: emitResult(id, name, payload)
+   *   - STREAM/PUB-SUB: emit("updates", {{"value", x}})  // call repeatedly
+   *   - STATE: emit("theme", {{"mode", "dark"}})
+   */
+  void emit(const std::string &name, const nlohmann::json &payload) {
+    emitEnvelope("event", name, payload);
+  }
+
+  void emitResult(const std::string &id, const std::string &name,
+                  const nlohmann::json &payload) {
+    emitEnvelope("result", name, payload, id);
+  }
+
+  void emitError(const std::string &id, const std::string &name,
+                 const std::string &message) {
+    emitEnvelope("error", name, nlohmann::json::object(), id, message);
+  }
+
+  /**
+   * call() - Make a call to the frontend and wait for response
+   *
+   * Enables bidirectional request/response:
+   *   Backend: auto answer = connect.call("ui.promptUser", {{"msg", "Sure?"}});
+   *   Frontend: connect.ui.handlePromptUser = async (data) => { ... return result; };
+   */
+  void call(const std::string &name, const nlohmann::json &payload,
+            std::function<void(const nlohmann::json &)> onResult = nullptr,
+            std::function<void(const std::string &)> onError = nullptr) {
+    auto id = std::to_string(std::chrono::steady_clock::now().time_since_epoch().count());
+    
+    if (onResult || onError) {
+      // Store pending callback for when frontend responds
+      on(name + ".__result__." + id, [this, id, name, onResult, onError](const nlohmann::json &p) {
+        if (p.contains("error") && onError) {
+          onError(p["error"].get<std::string>());
+        } else if (onResult) {
+          onResult(p.value("payload", nlohmann::json::object()));
+        }
+      });
+    }
+
+    emitEnvelope("call", name, payload, id);
+  }
+
+  // Parse and dispatch incoming messages from frontend
+  void dispatchMessage(const std::string &message) {
+    try {
+      auto j = nlohmann::json::parse(message);
+      nlohmann::json envelope = j;
+
+      if (j.is_object() && j.value("method", std::string()) ==
+                               "connection.dispatch") {
+        auto paramsIt = j.find("params");
+        if (paramsIt != j.end() && paramsIt->is_array() &&
+            !paramsIt->empty() && (*paramsIt)[0].is_object()) {
+          envelope = (*paramsIt)[0];
+        }
+      }
+
+      std::string name = envelope.value("name", "");
+      nlohmann::json payload =
+          envelope.value("payload", nlohmann::json::object());
+      std::string kind = envelope.value("kind", "fire");
+      std::string id = envelope.value("id", "");
+      
+      if (name.empty()) {
+        return;
+      }
+
+      if (kind == "call") {
+        try {
+          nlohmann::json responsePayload = nlohmann::json::object();
+          auto callIt = callHandlers.find(name);
+          if (callIt != callHandlers.end()) {
+            responsePayload = callIt->second(payload);
+          } else {
+            responsePayload = handleCall(name, payload);
+          }
+          if (!id.empty()) {
+            emitResult(id, name, responsePayload);
+          }
+        } catch (const std::exception &e) {
+          if (!id.empty()) {
+            emitError(id, name, e.what());
+          }
+        } catch (...) {
+          if (!id.empty()) {
+            emitError(id, name, "Unknown error");
+          }
+        }
+        return;
+      }
+
+      if (kind == "result" || kind == "error") {
+        // Response from a frontend call — dispatch to pending listeners
+        std::string resultKey = name + ".__result__." + id;
+        auto listenersIt = eventHandlers.find(resultKey);
+        if (listenersIt != eventHandlers.end()) {
+          nlohmann::json resultPayload;
+          if (kind == "error") {
+            resultPayload["error"] = envelope.value("error", "Unknown error");
+          } else {
+            resultPayload["payload"] = payload;
+          }
+          for (const auto &listener : listenersIt->second) {
+            listener(resultPayload);
+          }
+          eventHandlers.erase(resultKey);
+        }
+        return;
+      }
+
+      if (kind == "sub") {
+        auto subIt = subscriptionHandlers.find(name);
+        if (subIt != subscriptionHandlers.end()) {
+          subIt->second(true, payload);
+        }
+        handleSubscription(name, true, payload);
+        return;
+      }
+
+      if (kind == "unsub") {
+        auto subIt = subscriptionHandlers.find(name);
+        if (subIt != subscriptionHandlers.end()) {
+          subIt->second(false, payload);
+        }
+        handleSubscription(name, false, payload);
+        return;
+      }
+
+      auto listenersIt = eventHandlers.find(name);
+      if (listenersIt != eventHandlers.end()) {
+        for (const auto &listener : listenersIt->second) {
+          listener(payload);
+        }
+      }
+
+      handleMessage(name, payload);
+    } catch (...) {
+      // Silently ignore malformed messages
+    }
+  }
+
+  void dispatch(const std::string &message) { dispatchMessage(message); }
+
+protected:
+  virtual nlohmann::json handleCall(const std::string &name,
+                                    const nlohmann::json &payload) {
+    handleMessage(name, payload);
+    return nlohmann::json::object();
+  }
+
+  virtual void handleSubscription(const std::string &name, bool subscribed,
+                                  const nlohmann::json &payload) {
+    (void)name;
+    (void)subscribed;
+    (void)payload;
+  }
+
+  /**
+   * handleMessage() - Receive messages from the frontend
+   *
+   * Override this to handle incoming messages. This is your "on()" equivalent.
+   *
+   * For the new semantic API, prefer using the generated connect:: namespace
+   * instead of overriding this method:
+   *
+   *   connect::user.handleFetch = [](const json& p) -> json {
+   *     return database.getUser(p["id"]);
+   *   };
+   *
+   * This method remains for backward compatibility and catch-all handling.
+   */
+  virtual void handleMessage(const std::string &name,
+                             const nlohmann::json &payload) {
+    (void)name;
+    (void)payload;
+  }
+};
+
+void bindConnect(Window &window, Connect &connect);
+
+// Legacy aliases for backwards compatibility
+using Bridge = Connect;
+using Connection = Connect;
+
+} // namespace plusui