plusui-native-core 0.1.3 → 0.1.5

package/Core/Features/Browser/browser.ts

@@ -0,0 +1,182 @@
+export interface BrowserState {
+  url: string;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  isLoading: boolean;
+}
+
+export type NavigateCallback = (url: string) => void;
+export type StateCallback = (state: BrowserState) => void;
+export type LoadCallback = () => void;
+export type ErrorCallback = (error: string) => void;
+
+let _invoke: ((method: string, args?: unknown[]) => Promise<unknown>) | null = null;
+
+export function setInvokeFn(fn: (method: string, args?: unknown[]) => Promise<unknown>) {
+  _invoke = fn;
+}
+
+async function invoke(method: string, args?: unknown[]): Promise<unknown> {
+  if (!_invoke) {
+    if (typeof window !== 'undefined' && (window as any).__invoke__) {
+      _invoke = (window as any).__invoke__;
+    } else {
+      throw new Error('Browser API not initialized');
+    }
+  }
+  return _invoke(method, args);
+}
+
+const _navigateCallbacks: NavigateCallback[] = [];
+const _stateCallbacks: StateCallback[] = [];
+const _loadStartCallbacks: LoadCallback[] = [];
+const _loadEndCallbacks: LoadCallback[] = [];
+const _loadErrorCallbacks: ErrorCallback[] = [];
+let _currentState: BrowserState = { url: '', title: '', canGoBack: false, canGoForward: false, isLoading: false };
+let _routes: Record<string, string> = {};
+let _currentRoute: string = '/';
+
+// Setup event listeners from native backend
+if (typeof window !== 'undefined') {
+  (window as any).__onNavigate__ = (url: string) => {
+    _currentState.url = url;
+    _navigateCallbacks.forEach(cb => cb(url));
+  };
+  (window as any).__onBrowserState__ = (state: BrowserState) => {
+    _currentState = state;
+    _stateCallbacks.forEach(cb => cb(state));
+  };
+  (window as any).__onLoadStart__ = () => {
+    _currentState.isLoading = true;
+    _loadStartCallbacks.forEach(cb => cb());
+  };
+  (window as any).__onLoadEnd__ = () => {
+    _currentState.isLoading = false;
+    _loadEndCallbacks.forEach(cb => cb());
+  };
+  (window as any).__onLoadError__ = (error: string) => {
+    _currentState.isLoading = false;
+    _loadErrorCallbacks.forEach(cb => cb(error));
+  };
+}
+
+export const browser = {
+  async navigate(url: string): Promise<void> {
+    await invoke('browser.navigate', [url]);
+  },
+
+  async goBack(): Promise<void> {
+    await invoke('browser.goBack', []);
+  },
+
+  async goForward(): Promise<void> {
+    await invoke('browser.goForward', []);
+  },
+
+  async reload(): Promise<void> {
+    await invoke('browser.reload', []);
+  },
+
+  async stop(): Promise<void> {
+    await invoke('browser.stop', []);
+  },
+
+  async getUrl(): Promise<string> {
+    return await invoke('browser.getUrl', []) as Promise<string>;
+  },
+
+  async getTitle(): Promise<string> {
+    return await invoke('browser.getTitle', []) as Promise<string>;
+  },
+
+  getState(): BrowserState {
+    return { ..._currentState };
+  },
+
+  async canGoBack(): Promise<boolean> {
+    return await invoke('browser.canGoBack', []) as Promise<boolean>;
+  },
+
+  async canGoForward(): Promise<boolean> {
+    return await invoke('browser.canGoForward', []) as Promise<boolean>;
+  },
+
+  async isLoading(): Promise<boolean> {
+    return _currentState.isLoading;
+  },
+
+  onNavigate(callback: NavigateCallback): () => void {
+    _navigateCallbacks.push(callback);
+    return () => {
+      const idx = _navigateCallbacks.indexOf(callback);
+      if (idx > -1) _navigateCallbacks.splice(idx, 1);
+    };
+  },
+
+  onStateChange(callback: StateCallback): () => void {
+    _stateCallbacks.push(callback);
+    return () => {
+      const idx = _stateCallbacks.indexOf(callback);
+      if (idx > -1) _stateCallbacks.splice(idx, 1);
+    };
+  },
+
+  onLoadStart(callback: LoadCallback): () => void {
+    _loadStartCallbacks.push(callback);
+    return () => {
+      const idx = _loadStartCallbacks.indexOf(callback);
+      if (idx > -1) _loadStartCallbacks.splice(idx, 1);
+    };
+  },
+
+  onLoadEnd(callback: LoadCallback): () => void {
+    _loadEndCallbacks.push(callback);
+    return () => {
+      const idx = _loadEndCallbacks.indexOf(callback);
+      if (idx > -1) _loadEndCallbacks.splice(idx, 1);
+    };
+  },
+
+  onLoadError(callback: ErrorCallback): () => void {
+    _loadErrorCallbacks.push(callback);
+    return () => {
+      const idx = _loadErrorCallbacks.indexOf(callback);
+      if (idx > -1) _loadErrorCallbacks.splice(idx, 1);
+    };
+  }
+};
+
+export const router = {
+  setRoutes(routes: Record<string, string>): void {
+    _routes = routes;
+  },
+
+  getRoutes(): Record<string, string> {
+    return { ..._routes };
+  },
+
+  async push(route: string): Promise<void> {
+    _currentRoute = route;
+    const url = _routes[route] || route;
+    await browser.navigate(url);
+  },
+
+  async replace(route: string): Promise<void> {
+    _currentRoute = route;
+    const url = _routes[route] || route;
+    await browser.navigate(url);
+  },
+
+  getCurrentRoute(): string {
+    return _currentRoute;
+  },
+
+  async setInitialRoute(route: string): Promise<void> {
+    _currentRoute = route;
+    const url = _routes[route] || route;
+    await browser.navigate(url);
+  }
+};
+
+export default { browser, router };

package/Core/Features/Clipboard/clipboard.cpp

@@ -0,0 +1,234 @@
+#include <memory>
+#include <mutex>
+#include <plusui/clipboard.hpp>
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <AppKit/AppKit.h>
+#include <CoreFoundation/CoreFoundation.h>
+#else
+// Linux/GTK - would use GTK clipboard APIs
+#include <gtk/gtk.h>
+#endif
+
+namespace PlusUI {
+
+struct Clipboard::Impl {
+  std::mutex mtx;
+  std::function<void(const std::string &)> changeCallback;
+
+#ifdef _WIN32
+  HWND hwnd = nullptr;
+#endif
+};
+
+Clipboard::Clipboard() : pImpl(new Impl()) {
+#ifdef _WIN32
+  // Create hidden window for clipboard monitoring
+  // This would be done properly in a full implementation
+#endif
+}
+
+Clipboard::~Clipboard() { delete pImpl; }
+
+std::string Clipboard::getText() {
+  std::lock_guard<std::mutex> lock(pImpl->mtx);
+
+#ifdef _WIN32
+  if (!OpenClipboard(nullptr)) {
+    return "";
+  }
+
+  HANDLE hData = GetClipboardData(CF_UNICODETEXT);
+  if (hData == nullptr) {
+    CloseClipboard();
+    return "";
+  }
+
+  wchar_t *pszText = static_cast<wchar_t *>(GlobalLock(hData));
+  if (pszText == nullptr) {
+    CloseClipboard();
+    return "";
+  }
+
+  // Convert wide string to UTF-8
+  int size = WideCharToMultiByte(CP_UTF8, 0, pszText, -1, nullptr, 0, nullptr,
+                                 nullptr);
+  std::string text(size - 1, '\0');
+  WideCharToMultiByte(CP_UTF8, 0, pszText, -1, &text[0], size, nullptr,
+                      nullptr);
+
+  GlobalUnlock(hData);
+  CloseClipboard();
+
+  return text;
+
+#elif defined(__APPLE__)
+  @autoreleasepool {
+    NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+    NSString *str = [pasteboard stringForType:NSPasteboardTypeString];
+    if (str) {
+      return std::string([str UTF8String]);
+    }
+    return "";
+  }
+
+#else
+  // Linux/GTK implementation
+  if (!gtk_init_check(nullptr, nullptr)) {
+    return "";
+  }
+
+  GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+  gchar *text = gtk_clipboard_wait_for_text(clipboard);
+
+  std::string result;
+  if (text) {
+    result = text;
+    g_free(text);
+  }
+
+  return result;
+#endif
+}
+
+void Clipboard::setText(const std::string &text) {
+  std::lock_guard<std::mutex> lock(pImpl->mtx);
+
+#ifdef _WIN32
+  if (!OpenClipboard(nullptr)) {
+    return;
+  }
+
+  EmptyClipboard();
+
+  // Convert UTF-8 to wide string
+  int size = MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, nullptr, 0);
+  HGLOBAL hGlob = GlobalAlloc(GMEM_MOVEABLE, size * sizeof(wchar_t));
+  if (hGlob) {
+    wchar_t *pGlob = static_cast<wchar_t *>(GlobalLock(hGlob));
+    MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, pGlob, size);
+    GlobalUnlock(hGlob);
+    SetClipboardData(CF_UNICODETEXT, hGlob);
+  }
+
+  CloseClipboard();
+
+#elif defined(__APPLE__)
+  @autoreleasepool {
+    NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+    [pasteboard clearContents];
+    NSString *str = [NSString stringWithUTF8String:text.c_str()];
+    [pasteboard setString:str forType:NSPasteboardTypeString];
+  }
+
+#else
+  // Linux/GTK implementation
+  if (!gtk_init_check(nullptr, nullptr)) {
+    return;
+  }
+
+  GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+  gtk_clipboard_set_text(clipboard, text.c_str(), -1);
+#endif
+
+  // Trigger change callback
+  if (pImpl->changeCallback) {
+    pImpl->changeCallback(text);
+  }
+}
+
+bool Clipboard::hasText() {
+#ifdef _WIN32
+  return IsClipboardFormatAvailable(CF_UNICODETEXT) != 0;
+
+#elif defined(__APPLE__)
+  @autoreleasepool {
+    NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+    return
+        [pasteboard availableTypeFromArray:@[ NSPasteboardTypeString ]] != nil;
+  }
+
+#else
+  // Linux/GTK implementation
+  if (!gtk_init_check(nullptr, nullptr)) {
+    return false;
+  }
+
+  GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+  return gtk_clipboard_wait_is_text_available(clipboard);
+#endif
+}
+
+std::string Clipboard::getImage() {
+  // Image support would require base64 encoding/decoding
+  // Platform-specific image clipboard handling
+  // This is a placeholder for now
+  return "";
+}
+
+void Clipboard::setImage(const std::string &base64Data) {
+  // Image support would require base64 decoding
+  // Platform-specific image clipboard handling
+  // This is a placeholder for now
+}
+
+bool Clipboard::hasImage() {
+#ifdef _WIN32
+  return IsClipboardFormatAvailable(CF_DIB) != 0 ||
+         IsClipboardFormatAvailable(CF_BITMAP) != 0;
+
+#elif defined(__APPLE__)
+  @autoreleasepool {
+    NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+    return [pasteboard availableTypeFromArray:@[
+             NSPasteboardTypePNG, NSPasteboardTypeTIFF
+           ]] != nil;
+  }
+
+#else
+  // Linux/GTK implementation
+  if (!gtk_init_check(nullptr, nullptr)) {
+    return false;
+  }
+
+  GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+  return gtk_clipboard_wait_is_image_available(clipboard);
+#endif
+}
+
+void Clipboard::clear() {
+  std::lock_guard<std::mutex> lock(pImpl->mtx);
+
+#ifdef _WIN32
+  if (OpenClipboard(nullptr)) {
+    EmptyClipboard();
+    CloseClipboard();
+  }
+
+#elif defined(__APPLE__)
+  @autoreleasepool {
+    NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+    [pasteboard clearContents];
+  }
+
+#else
+  // Linux/GTK implementation
+  if (!gtk_init_check(nullptr, nullptr)) {
+    return;
+  }
+
+  GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+  gtk_clipboard_clear(clipboard);
+#endif
+}
+
+void Clipboard::onClipboardChange(
+    std::function<void(const std::string &)> callback) {
+  std::lock_guard<std::mutex> lock(pImpl->mtx);
+  pImpl->changeCallback = callback;
+}
+
+} // namespace PlusUI

package/Core/Features/Clipboard/clipboard.ts

@@ -0,0 +1,113 @@
+/**
+ * Clipboard API - Cross-platform clipboard management
+ *
+ * Provides access to system clipboard for text and images.
+ * Supports clipboard change events.
+ */
+
+export interface ClipboardAPI {
+  // 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 {
+  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;
+  }
+
+  /**
+   * 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);
+}