plusui-native-core 0.1.55 → 0.1.57

package/Core/CMakeLists.txt

@@ -29,7 +29,7 @@ add_library(plusui STATIC
     Features/Clipboard/clipboard.cpp
     Features/Menu/menu.cpp
     Features/Keyboard/keyboard.cpp
-    Features/Connection/connection.cpp
+    Features/Connection/connect.cpp
     Features/WebGPU/webgpu.cpp
 )
 

package/Core/Features/App/app.cpp

@@ -7,31 +7,8 @@
 #include <plusui/tray.hpp>
 #include <plusui/window.hpp>
 
-#include <bridge.hpp> // Generated generated bridge
-
 namespace plusui {
 
-// --- Bridge Implementation (Demo) ---
-class DemoBridge : public bridge::GeneratedBridge {
-public:
-  nlohmann::json handle_greet(const nlohmann::json &args) override {
-    std::string name = args.value("name", "Guest");
-    return {{"message", "Hello from C++, " + name + "!"}};
-  }
-
-  void handle_log(const nlohmann::json &args) override {
-    std::string msg = args.value("msg", "");
-    std::cout << "[Client Log] " << msg << std::endl;
-  }
-
-  void handle_minimize(const nlohmann::json &args) override {
-    // We need access to the window to minimize it.
-    // For now, we'll just log. In a real app, Bridge might hold a reference to
-    // WindowController.
-    std::cout << "[Client] Requested minimize" << std::endl;
-  }
-};
-
 struct App::Impl {
   bool running = false;
 };
@@ -151,39 +128,6 @@ Window App::Builder::build() {
     }
   }
 
-  // --- Initialize Bridge ---
-  // Create the bridge instance
-  auto bridge = std::make_shared<DemoBridge>();
-
-  // Hook 1: Window -> Bridge (Inbound)
-  webviewWin.onMessage(
-      [bridge](const std::string &msg) { bridge->dispatch(msg); });
-
-  // Hook 2: Bridge -> Window (Outbound)
-  // We capture webviewWin by value (it's a lightweight handle)
-  bridge->setOutboundHandler([webviewWin](const std::string &msg) mutable {
-    webviewWin.postMessage(msg);
-  });
-
-  // Keep bridge alive?
-  // Since webviewWin.onMessage captures 'bridge', the bridge is kept alive by
-  // the Window. And 'bridge' outbound handler captures 'webviewWin', keeping
-  // Window alive. Cycle exists, but ensures lifetime match.
-
-  // Optional: Emit an initial event
-  bridge->emit_onResize(config.width, config.height);
-
-  // Hook 3: File Drop
-  webviewWin.onFileDrop([bridge](const std::string &jsonStr) {
-    if (jsonStr.empty())
-      return;
-    try {
-      auto j = nlohmann::json::parse(jsonStr);
-      bridge->emit_onFileDrop(j);
-    } catch (...) {
-    }
-  });
-
   return webviewWin;
 }
 

package/Core/Features/App/app.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface AppConfig {
   title?: string;
   width?: number;
@@ -20,6 +22,7 @@ export interface InvokeOptions {
 }
 
 export class App {
+  public readonly connect = connect.feature('app');
   private initialized = false;
 
   constructor(

package/Core/Features/Browser/browser.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface BrowserState {
   url: string;
   title: string;
@@ -62,6 +64,8 @@ if (typeof window !== 'undefined') {
 }
 
 export const browser = {
+  connect: connect.feature('browser'),
+
   async navigate(url: string): Promise<void> {
     await invoke('browser.navigate', [url]);
   },
@@ -160,6 +164,8 @@ export const browser = {
 };
 
 export const router = {
+  connect: connect.feature('router'),
+
   setRoutes(routes: Record<string, string>): void {
     _routes = routes;
   },

package/Core/Features/Clipboard/clipboard.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * Clipboard API - Cross-platform clipboard management
  *
@@ -24,6 +26,7 @@ export interface ClipboardAPI {
 }
 
 export class Clipboard implements ClipboardAPI {
+  public readonly connect = connect.feature('clipboard');
   private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>;
   private onFn: (event: string, callback: (data: unknown) => void) => () => void;
 

package/Core/Features/Connection/README.md

@@ -9,7 +9,7 @@ The **Connection Feature** is PlusUI's absurdly simple system for frontend ↔ b
 Just `emit()` and `on()` handle all communication patterns:
 
 | Keyword | Pattern | Direction | Use Cases |
-|---------|---------|-----------|-----------|
+| --------- | --------- | ----------- | ----------- |
 | **EVENT** | Fire & forget | One way → | Notifications, commands, logging |
 | **CALL** | Request/response | Two ways ↔ | Get data, save data, RPC |
 | **STREAM** | Continuous data | One way push → | Real-time updates, monitoring |
@@ -46,29 +46,18 @@ connect.emit('greet', { name: 'World' });
 ```cpp
 #include <plusui/connect.hpp>
 
-class MyConnect : public plusui::Connect {
-protected:
-  void handleMessage(const Envelope& env) override {
-    // Listen for messages from frontend
-    if (env.kind == MessageKind::Fire && env.name == "greet") {
-      std::string name = env.payload["name"];
-      
-      // Respond by emitting back
-      emit("greetResponse", {{"message", "Hello, " + name + "!"}});
-    }
-  }
+plusui::Connect connect;
 
-public:
-  // Emit messages to frontend
-  void emit(const std::string& name, const nlohmann::json& data) {
-    event(name, data);
-  }
+connect.on("greet", [&connect](const nlohmann::json& payload) {
+  std::string user = payload.value("name", "World");
+  connect.emit("greetResponse", {{"message", "Hello, " + user + "!"}});
+});
 
-  // Example: notify frontend of window resize
-  void onWindowResize(int w, int h) {
-    emit("resize", {{"width", w}, {"height", h}});
-  }
-};
+// Wire backend connect ↔ window bridge once
+plusui::bindConnect(mainWindow, connect);
+
+// Example: backend push to frontend
+connect.emit("resize", {{"width", 1280}, {"height", 720}});
 ```
 
 ### Listen on Frontend
@@ -98,17 +87,42 @@ connect.on('messageName', (data) => {
 ### Backend
 
 ```cpp
-// Listen for messages (in handleMessage)
-void handleMessage(const Envelope& env) override {
-  if (env.kind == MessageKind::Fire && env.name == "messageName") {
-    // process env.payload
-  }
-}
+plusui::Connect connect;
+
+// Listen for messages
+connect.on("messageName", [](const nlohmann::json& payload) {
+  // process payload
+});
 
 // Send messages
-void emit(const std::string& name, const nlohmann::json& data) {
-  event(name, data);
-}
+connect.emit("messageName", {{"key", "value"}});
+
+// Bridge window <-> connect runtime
+plusui::bindConnect(mainWindow, connect);
+
+// Optional: call primitive support
+connect.onCall("getUser", [](const nlohmann::json& payload) {
+  return nlohmann::json{{"id", payload.value("id", 0)}, {"name", "Ada"}};
+});
+
+// Optional: stream/query subscription hooks
+connect.onSubscription("cpu", [](bool subscribed, const nlohmann::json&) {
+  if (subscribed) {
+    startCpuStream();
+  } else {
+    stopCpuStream();
+  }
+});
+```
+
+### Feature-Scoped Names
+
+Use `connect` for custom global channels, and `feature.connect` when you want automatic namespacing:
+
+```typescript
+window.connect.emit('resized', { width: 1200, height: 800 });   // -> "window.resized"
+clipboard.connect.emit('changed', { text: 'hello' });           // -> "clipboard.changed"
+connect.emit('custom.appEvent', { ok: true });                  // custom/global channel
 ```
 
 ## 💡 Design Your Own Patterns
@@ -124,13 +138,11 @@ connect.emit('getUser', { id: 123 });
 ```
 
 ```cpp
-// Backend
-void handleMessage(const Envelope& env) override {
-  if (env.name == "getUser") {
-    auto user = database.findUser(env.payload["id"]);
-    emit("getUserResponse", {{"user", user}});
-  }
-}
+plusui::Connect connect;
+connect.onCall("getUser", [](const nlohmann::json& payload) {
+  auto user = database.findUser(payload["id"]);
+  return nlohmann::json{{"user", user}};
+});
 ```
 
 ### Notifications

package/Core/Features/Connection/connect.cpp

@@ -1,57 +1,34 @@
 #include <plusui/connect.hpp>
+#include <plusui/window.hpp>
 
 namespace plusui {
 
-// Connect implementation
-//
-// The Connect class is header-only (see plusui/connect.hpp).
-// This file is reserved for future non-template implementation details.
-//
-// TWO METHODS. FIVE PRIMITIVES. EVERYTHING YOU NEED.
-//
-// To use Connect:
-// 1. Create a class that inherits from plusui::Connect
-// 2. Override handleMessage(name, payload) to receive messages
-// 3. Use emit(name, payload) to send messages to frontend
-//
-// Example - All 5 Primitives:
-//
-//   class MyApp : public plusui::Connect {
-//   protected:
-//     void handleMessage(const std::string& name, const nlohmann::json& data) override {
-//       // EVENT: fire & forget
-//       if (name == "notification") {
-//         showNotification(data["message"].get<std::string>());
-//       }
-//       
-//       // CALL: request/response
-//       if (name == "getUser") {
-//         auto userId = data["id"].get<int>();
-//         emit("userData", {{"name", "John"}, {"id", userId}});
-//       }
-//       
-//       // STREAM: continuous updates (start streaming)
-//       if (name == "subscribeCPU") {
-//         startCPUMonitor(); // Will call emit("cpu", ...) repeatedly
-//       }
-//       
-//       // QUERY: request + stream responses
-//       if (name == "search") {
-//         auto query = data["query"].get<std::string>();
-//         for (auto& result : searchDatabase(query)) {
-//           emit("searchResult", result); // Multiple results
-//         }
-//       }
-//       
-//       // STATE: synced value
-//       if (name == "theme") {
-//         currentTheme = data["mode"].get<std::string>();
-//         emit("theme", data); // Sync back to frontend
-//       }
-//     }
-//   };
-//
-// See Core/Features/Connection/README.md for more details.
+namespace {
+
+std::string makeConnectionDispatchScript(const nlohmann::json &message) {
+	return "(function(){const m=" + message.dump() +
+				 ";if(typeof globalThis.__plusuiConnectionMessage === 'function'){"
+				 "globalThis.__plusuiConnectionMessage(m);}"
+				 "window.dispatchEvent(new CustomEvent('plusui:connection:message',"
+				 "{detail:m}));})();";
+}
+
+} // namespace
+
+void bindConnect(Window &window, Connect &connect) {
+	window.onMessage([&connect](const std::string &message) {
+		connect.dispatchMessage(message);
+	});
+
+	connect.setOutbound([&window](const std::string &message) {
+		try {
+			auto parsed = nlohmann::json::parse(message);
+			window.executeScript(makeConnectionDispatchScript(parsed));
+		} catch (...) {
+			// Ignore malformed outbound payloads
+		}
+	});
+}
 
 }
 

package/Core/Features/Connection/connect.ts

@@ -180,7 +180,93 @@ export const connect = {
   on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
     return connectionClient.on<TData>(name, callback);
   },
+
+  feature: (scope: string): FeatureConnect => {
+    return createFeatureConnect(scope);
+  },
 };
 
 // Export the raw client for advanced use cases (call, fire, stream, channel)
 export const connection = connectionClient;
+
+export type FeatureConnect = {
+  emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => void;
+  on: <TData = unknown>(name: string, callback: (payload: TData) => void) => (() => void);
+  call: <TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn) => Promise<TOut>;
+  stream: <TData = unknown>(name: string) => {
+    subscribe: (callback: (payload: TData) => void) => (() => void);
+  };
+  channel: <TData = unknown>(name: string) => {
+    subscribe: (callback: (payload: TData) => void) => (() => void);
+    publish: (payload: TData) => void;
+  };
+  scoped: (scope: string) => FeatureConnect;
+};
+
+function scopeName(scope: string, name: string): string {
+  if (name.startsWith(`${scope}.`)) {
+    return name;
+  }
+  return `${scope}.${name}`;
+}
+
+async function invokeScoped(method: string, payload?: unknown): Promise<unknown> {
+  const host = globalThis as any;
+  if (typeof host.__invoke__ !== 'function') {
+    return undefined;
+  }
+
+  const args = payload === undefined ? [] : [payload];
+  return host.__invoke__(method, args);
+}
+
+export function createFeatureConnect(scope: string): FeatureConnect {
+  return {
+    emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => {
+      const scoped = scopeName(scope, name);
+      void invokeScoped(scoped, payload);
+      connect.emit(scoped, payload);
+
+      if (typeof window !== 'undefined') {
+        window.dispatchEvent(new CustomEvent(`plusui:${scoped}`, { detail: payload }));
+      }
+    },
+    on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
+      const scoped = scopeName(scope, name);
+      const offConnect = connect.on<TData>(scoped, callback);
+
+      if (typeof window === 'undefined') {
+        return offConnect;
+      }
+
+      const domHandler = (event: Event) => {
+        const custom = event as CustomEvent<TData>;
+        callback(custom.detail);
+      };
+
+      window.addEventListener(`plusui:${scoped}`, domHandler as EventListener);
+
+      return () => {
+        offConnect();
+        window.removeEventListener(`plusui:${scoped}`, domHandler as EventListener);
+      };
+    },
+    call: <TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn): Promise<TOut> => {
+      const scoped = scopeName(scope, name);
+      const host = globalThis as any;
+
+      if (typeof host.__invoke__ === 'function') {
+        return invokeScoped(scoped, payload) as Promise<TOut>;
+      }
+
+      return connection.call<TOut, TIn>(scoped, payload);
+    },
+    stream: <TData = unknown>(name: string) => {
+      return connection.stream<TData>(scopeName(scope, name));
+    },
+    channel: <TData = unknown>(name: string) => {
+      return connection.channel<TData>(scopeName(scope, name));
+    },
+    scoped: (childScope: string) => createFeatureConnect(scopeName(scope, childScope)),
+  };
+}

package/Core/Features/Display/display.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface DisplayMode {
   width: number;
   height: number;
@@ -32,6 +34,8 @@ export interface Display {
 }
 
 export class DisplayAPI {
+  public readonly connect = connect.feature('display');
+
   constructor(
     private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>
   ) {}

package/Core/Features/FileDrop/filedrop.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * FileDrop API - Cross-platform drag & drop file handling
  *
@@ -77,6 +79,7 @@ export interface FileDropAPI {
 }
 
 export class FileDrop implements FileDropAPI {
+  public readonly connect = connect.feature('fileDrop');
   private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>;
   private onFn: (event: string, callback: (data: unknown) => void) => () => void;
 

package/Core/Features/Keyboard/keyboard.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export enum KeyCode {
   Unknown = 0,
   Space = 32,
@@ -53,6 +55,7 @@ export type KeyEventCallback = (event: KeyEvent) => void;
 export type ShortcutCallback = () => void;
 
 export class KeyboardAPI {
+  public readonly connect = connect.feature('keyboard');
   private shortcutHandlers: Map<string, ShortcutCallback> = new Map();
 
   constructor(

package/Core/Features/Menu/menu.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * PlusUI Menu API
  *
@@ -68,6 +70,7 @@ export interface ContextInfo {
 // ============================================================================
 
 export class MenuAPI {
+    public readonly connect = connect.feature('menu');
     private clickHandlers: Map<string, (item: MenuItem) => void> = new Map();
     private contextMenuItems: MenuItem[] = [];
     private contextMenuEnabled = false;

package/Core/Features/Tray/tray.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface TrayMenuItem {
   id: string;
   label: string;
@@ -16,6 +18,8 @@ export interface TrayIconData {
 }
 
 export class TrayAPI {
+  public readonly connect = connect.feature('tray');
+
   constructor(
     private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>,
     private eventFn: (event: string, callback: (...args: unknown[]) => void) => () => void

package/Core/Features/WebGPU/webgpu.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * WebGPU Frontend API Wrapper
  *
@@ -561,6 +563,7 @@ export function createWebGPU(
  * Global WebGPU namespace (like navigator.gpu)
  */
 class WebGPUNamespace {
+  public readonly connect = connect.feature('webgpu');
   private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>;
   private onFn: (event: string, callback: (data: unknown) => void) => () => void;