plusui-native-core 0.1.65 → 0.1.68

package/Core/Features/Clipboard/clipboard.ts

@@ -1,127 +1,92 @@
-import { connect } from '../Connection/connect';
-
-/**
- * Clipboard API - Cross-platform clipboard management
- *
- * Provides access to system clipboard for text and images.
- * Supports clipboard change events.
- */
-
-export interface ClipboardAPI {
-  on<TData = unknown>(name: string, callback: (payload: TData) => void): () => void;
-  emit<TIn = Record<string, unknown>>(name: string, payload: TIn): void;
-
-  // Text operations
-  getText(): Promise<string>;
-  setText(text: string): Promise<void>;
-  hasText(): Promise<boolean>;
-
-  // Image operations (base64 encoded)
-  getImage(): Promise<string>;
-  setImage(base64Data: string): Promise<void>;
-  hasImage(): Promise<boolean>;
-
-  // Clear clipboard
-  clear(): Promise<void>;
-
-  // Events
-  onClipboardChange(callback: (text: string) => void): () => void;
-}
-
-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;
-
-  constructor(
-    invokeFn: (name: string, args?: unknown[]) => Promise<unknown>,
-    onFn: (event: string, callback: (data: unknown) => void) => () => void
-  ) {
-    this.invokeFn = invokeFn;
-    this.onFn = onFn;
-  }
-
-  on<TData = unknown>(name: string, callback: (payload: TData) => void): () => void {
-    return this.connect.on<TData>(name, callback);
-  }
-
-  emit<TIn = Record<string, unknown>>(name: string, payload: TIn): void {
-    this.connect.emit<TIn>(name, payload);
-  }
-
-  /**
-   * Get text from clipboard
-   * @returns Current clipboard text content
-   */
-  async getText(): Promise<string> {
-    return (await this.invokeFn('clipboard.getText')) as string;
-  }
-
-  /**
-   * Set clipboard text
-   * @param text - Text to copy to clipboard
-   */
-  async setText(text: string): Promise<void> {
-    await this.invokeFn('clipboard.setText', [text]);
-  }
-
-  /**
-   * Check if clipboard has text
-   * @returns True if clipboard contains text
-   */
-  async hasText(): Promise<boolean> {
-    return (await this.invokeFn('clipboard.hasText')) as boolean;
-  }
-
-  /**
-   * Get image from clipboard as base64
-   * @returns Base64 encoded image data
-   */
-  async getImage(): Promise<string> {
-    return (await this.invokeFn('clipboard.getImage')) as string;
-  }
-
-  /**
-   * Set clipboard image from base64 data
-   * @param base64Data - Base64 encoded image data
-   */
-  async setImage(base64Data: string): Promise<void> {
-    await this.invokeFn('clipboard.setImage', [base64Data]);
-  }
-
-  /**
-   * Check if clipboard has image
-   * @returns True if clipboard contains image
-   */
-  async hasImage(): Promise<boolean> {
-    return (await this.invokeFn('clipboard.hasImage')) as boolean;
-  }
-
-  /**
-   * Clear clipboard contents
-   */
-  async clear(): Promise<void> {
-    await this.invokeFn('clipboard.clear');
-  }
-
-  /**
-   * Listen for clipboard changes
-   * @param callback - Function called when clipboard changes
-   * @returns Cleanup function to remove listener
-   */
-  onClipboardChange(callback: (text: string) => void): () => void {
-    return this.onFn('clipboard:change', (data) => {
-      callback(data as string);
-    });
-  }
-}
-
-/**
- * Factory function to create Clipboard instance
- */
-export function createClipboard(
-  invokeFn: (name: string, args?: unknown[]) => Promise<unknown>,
-  onFn: (event: string, callback: (data: unknown) => void) => () => void
-): Clipboard {
-  return new Clipboard(invokeFn, onFn);
-}
+/**
+ * Clipboard API - Cross-platform clipboard management
+ * 
+ * Direct method calls - no .on/.emit
+ * 
+ * Usage:
+ *   import { clipboard } from '@plusui/api';
+ *   
+ *   const text = await clipboard.getText();
+ *   clipboard.setText('hello');
+ *   clipboard.onChange((text) => { ... });
+ */
+
+export interface ClipboardAPI {
+  getText(): Promise<string>;
+  setText(text: string): Promise<void>;
+  hasText(): Promise<boolean>;
+  getImage(): Promise<string>;
+  setImage(base64Data: string): Promise<void>;
+  hasImage(): Promise<boolean>;
+  clear(): Promise<void>;
+  onChange(callback: (text: string) => void): () => void;
+}
+
+let _invoke: ((name: string, args?: unknown[]) => Promise<unknown>) | null = null;
+let _event: ((event: string, callback: (data: unknown) => void) => () => void) | null = null;
+
+export function setInvokeFn(fn: (name: string, args?: unknown[]) => Promise<unknown>) {
+  _invoke = fn;
+}
+
+export function setEventFn(fn: (event: string, callback: (data: unknown) => void) => () => void) {
+  _event = fn;
+}
+
+async function invoke<T = unknown>(name: string, args?: unknown[]): Promise<T> {
+  if (!_invoke) {
+    if (typeof window !== 'undefined' && (window as any).__invoke__) {
+      _invoke = (window as any).__invoke__;
+    } else {
+      throw new Error('Clipboard API not initialized');
+    }
+  }
+  return _invoke!(name, args) as Promise<T>;
+}
+
+function eventHandler(event: string, callback: (data: unknown) => void): () => void {
+  if (!_event) {
+    if (typeof window !== 'undefined' && (window as any).__on__) {
+      _event = (window as any).__on__;
+    } else {
+      return () => {};
+    }
+  }
+  return _event!(event, callback);
+}
+
+export const clipboard: ClipboardAPI = {
+  async getText(): Promise<string> {
+    return invoke<string>('clipboard.getText');
+  },
+
+  async setText(text: string): Promise<void> {
+    await invoke('clipboard.setText', [text]);
+  },
+
+  async hasText(): Promise<boolean> {
+    return invoke<boolean>('clipboard.hasText');
+  },
+
+  async getImage(): Promise<string> {
+    return invoke<string>('clipboard.getImage');
+  },
+
+  async setImage(base64Data: string): Promise<void> {
+    await invoke('clipboard.setImage', [base64Data]);
+  },
+
+  async hasImage(): Promise<boolean> {
+    return invoke<boolean>('clipboard.hasImage');
+  },
+
+  async clear(): Promise<void> {
+    await invoke('clipboard.clear');
+  },
+
+  onChange(callback: (text: string) => void): () => void {
+    return eventHandler('clipboard:change', callback as (data: unknown) => void);
+  },
+};
+
+export default clipboard;

package/Core/Features/Connection/README.md

@@ -1,214 +1,111 @@
-# PlusUI Connection Feature
-
-## 🎯 Overview
-
-The **Connection Feature** is PlusUI's absurdly simple system for frontend ↔ backend communication. Use **`feature.emit()`** and **`feature.on()`** on frontend, mirrored by scoped channels on backend.
-
-## ✨ The 5 Primitives That Cover Everything
-
-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 |
-| **QUERY** | Request + stream | Two way + many ↔↔↔ | Search results, paginated data |
-| **STATE** | Synced value | Both ways ↕ | Theme, settings, shared state |
-
-## ✨ Why It's Simple
-
-- **Two methods**: `emit()` and `on()` - that's all
-- **Mirror API**: Same methods on both frontend and backend
-- **Two-way**: Frontend → Backend AND Backend → Frontend
-- **No schema**: Write code directly, no extra files
-- **No bindgen**: No code generation step
-- **Total flexibility**: Design your own patterns (RPC, pub/sub, streaming, whatever)
-
-## 🚀 Quick Start
-
-### Send Message →
-
-```typescript
-import { connect } from 'plusui-native-core/connect';
-
-const custom = connect.feature('custom');
-
-// Listen for response
-custom.on('greetResponse', (data) => {
-  console.log(data.message); // "Hello, World!"
-});
-
-// Send message to backend
-custom.emit('greet', { name: 'World' });
-```
-
-### Receive & Respond
-
-```cpp
-#include <plusui/connect.hpp>
-
-plusui::Connect connect;
-
-auto customFeature = connect.feature("custom");
-
-customFeature.on("greet", [&connect](const nlohmann::json& payload) {
-  std::string user = payload.value("name", "World");
-  connect.emit("custom.greetResponse", {{"message", "Hello, " + user + "!"}});
-});
-
-// Wire backend connect ↔ window bridge once
-plusui::bindConnect(mainWindow, connect);
-
-// Example: backend push to frontend
-connect.emit("custom.resize", {{"width", 1280}, {"height", 720}});
-```
-
-### Listen on Frontend
-
-```typescript
-// Listen for messages from backend
-custom.on('resize', (data) => {
-  console.log(`${data.width}x${data.height}`);
-  updateLayout(data);
-});
-```
-
-## 📖 Complete API
-
-### Frontend
-
-```typescript
-// Send message
-connect.emit('messageName', { key: 'value' });
-
-// Listen for messages
-connect.on('messageName', (data) => {
-  console.log(data);
-});
-```
-
-### Backend
-
-```cpp
-plusui::Connect connect;
-
-// Listen for messages
-connect.on("messageName", [](const nlohmann::json& payload) {
-  // process payload
-});
-
-// Send messages
-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-scoped APIs when you want automatic namespacing:
-
-```typescript
-window.emit('resized', { width: 1200, height: 800 });           // -> "window.resized"
-clipboard.emit('changed', { text: 'hello' });                   // -> "clipboard.changed"
-
-// Also supported when you need explicit feature connect access:
-window.connect.emit('resized', { width: 1200, height: 800 });   // -> "window.resized"
-connect.emit('custom.appEvent', { ok: true });                  // custom/global channel
-```
-
-Backend can listen using fully scoped names, or use a scoped helper:
-
-```cpp
-plusui::Connect connect;
-plusui::bindConnect(mainWindow, connect);
-
-auto windowFeature = connect.feature("window");
-windowFeature.on("resized", [](const nlohmann::json& payload) {
-  // receives "window.resized"
-});
-
-connect.on("window.resized", [](const nlohmann::json& payload) {
-  // from window.emit('resized', ...) or window.connect.emit('resized', ...)
-});
-
-connect.on("clipboard.changed", [](const nlohmann::json& payload) {
-  // from clipboard.emit('changed', ...) or clipboard.connect.emit('changed', ...)
-});
-
-connect.on("custom.appEvent", [](const nlohmann::json& payload) {
-  // from connect.emit('custom.appEvent', ...)
-});
-```
-
-`plusui connect` scans frontend and backend `.emit()` / `.on()` calls and understands feature aliases, including:
-
-- `const custom = createFeatureConnect('custom'); custom.on('event', ...)`
-- `const custom = connect.feature('custom'); custom.emit('event', ...)`
-- `auto custom = connect.feature("custom"); custom.on("event", ...)`
-
-## 💡 Design Your Own Patterns
-
-### Request/Response Pattern
-
-```typescript
-// Frontend
-connect.on('getUserResponse', (data) => {
-  console.log(data.user);
-});
-connect.emit('getUser', { id: 123 });
-```
-
-```cpp
-plusui::Connect connect;
-connect.onCall("getUser", [](const nlohmann::json& payload) {
-  auto user = database.findUser(payload["id"]);
-  return nlohmann::json{{"user", user}};
-});
-```
-
-### Notifications
-
-```cpp
-// Backend sends
-emit("notification", {{"text", "File saved!"}});
-```
-
-```typescript
-// Frontend receives
-connect.on('notification', (data) => {
-  toast.success(data.text);
-});
-```
-
-### Bidirectional Chat
-
-```typescript
-// Both sides listen
-connect.on('chat', (data) => {
-  addToLog(data.message);
-});
-
-// Both sides send
-connect.emit('chat', { message: 'Hello!' });
-```
-
-## 🎯 That's It
-
-Two methods. Both sides. Use them however you want.
-
+# PlusUI Connection
+
+## Two methods. Five primitives. Same syntax.
+
+```typescript
+// TypeScript
+myEvent.on((data) => { ... });
+myEvent.emit({ value: 123 });
+```
+
+```cpp
+// C++ (identical!)
+myEvent.on([&](const json& p) { ... });
+myEvent.emit({{"value", 123}});
+```
+
+## Quick Start
+
+### 1. Write your code
+
+```typescript
+// frontend/src/app.ts
+import { download } from '../Connections/connections.gen';
+
+download.emit({ url: 'https://example.com/file.zip' });
+download.on((data) => {
+  progressBar.value = data.progress;
+});
+```
+
+```cpp
+// main.cpp
+#include "Connections/connections.gen.hpp"
+
+initChannels(connect);
+
+download.on([&](const json& p) {
+  auto url = p.value("url", "");
+  download.emit({{"progress", 50}});
+});
+```
+
+### 2. Generate channels
+
+```bash
+plusui connect
+```
+
+Scans your `.ts`, `.tsx`, `.cpp`, `.hpp` files for `.on()` and `.emit()` calls, generates:
+- `Connections/connections.gen.ts`
+- `Connections/connections.gen.hpp`
+
+## The 5 Primitives
+
+| Pattern | Direction | Use Case |
+|---------|-----------|----------|
+| **EVENT** | One way → | Notifications, commands |
+| **CALL** | Two ways ↔ | Request/response |
+| **STREAM** | Continuous → | Real-time updates |
+| **QUERY** | Many responses ↔↔↔ | Search, pagination |
+| **STATE** | Both ways ↕ | Synced values |
+
+All handled with just `.on()` and `.emit()`.
+
+## Generated Files
+
+### TypeScript (`connections.gen.ts`)
+
+```typescript
+import { _client } from 'plusui';
+
+export const download = {
+  on: <T = unknown>(cb: (data: T) => void) => _client.on('download', cb),
+  emit: (data: unknown) => _client.fire('download', data)
+};
+
+export const CONNECT_CHANNELS = ['download'] as const;
+```
+
+### C++ (`connections.gen.hpp`)
+
+```cpp
+#pragma once
+#include <plusui/plusui.hpp>
+
+namespace channels {
+  inline plusui::Connect* _connect = nullptr;
+  inline plusui::Connect::Channel download;
+}
+
+inline void initChannels(plusui::Connect& c) {
+  channels::_connect = &c;
+  channels::download = c.channel("download");
+}
+
+// Direct access (same as TypeScript)
+using channels::download;
+```
+
+## Built-in Channels
+
+```typescript
+import { win, clipboard, app } from 'plusui';
+
+win.on((data) => console.log(data.width));
+clipboard.emit({ text: 'copied!' });
+```
+
+## That's it.
+
+No schemas. No configuration. Write `.on()` and `.emit()`, run `plusui connect`.