electrobun 0.5.0-beta.0 → 0.6.0-beta.0

package/templates/interactive-playground/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "electrobun-interactive-playground",
-  "version": "0.0.1",
-  "description": "Interactive playground for exploring Electrobun features",
-  "type": "module",
-  "scripts": {
-    "build:dev": "electrobun build",
-    "build:canary": "electrobun build --canary",
-    "start": "electrobun build && electrobun dev",
-    "start:canary": "electrobun build --canary && electrobun dev --canary"
-  },
-  "dependencies": {
-    "electrobun": "latest"
-  }
-}

package/templates/interactive-playground/src/bun/demos/files.ts

@@ -1,70 +0,0 @@
-import { Utils } from "electrobun/bun";
-import { join } from "path";
-import { homedir } from "os";
-
-class FileManager {
-  async openFileDialog(options: {
-    multiple?: boolean;
-    fileTypes?: string[];
-    startingFolder?: string;
-  }) {
-    try {
-      const result = await Utils.openFileDialog({
-        startingFolder: options.startingFolder || join(homedir(), "Desktop"),
-        allowedFileTypes: options.fileTypes?.join(",") || "*",
-        canChooseFiles: true,
-        canChooseDirectory: false,
-        allowsMultipleSelection: options.multiple || false,
-      });
-
-      // Filter out empty strings
-      const filteredResult = result.filter(path => path.trim() !== "");
-      this.onFileSelected?.(filteredResult);
-      
-      return filteredResult;
-    } catch (error) {
-      console.error("File dialog error:", error);
-      return [];
-    }
-  }
-
-  async moveToTrash(path: string) {
-    try {
-      await Utils.moveToTrash(path);
-      this.onSystemEvent?.({ 
-        type: 'file-trashed', 
-        details: { path, success: true } 
-      });
-    } catch (error) {
-      console.error("Move to trash error:", error);
-      this.onSystemEvent?.({ 
-        type: 'file-trashed', 
-        details: { path, success: false, error: error.message } 
-      });
-      throw error;
-    }
-  }
-
-  async showInFinder(path: string) {
-    try {
-      await Utils.showItemInFolder(path);
-      this.onSystemEvent?.({ 
-        type: 'show-in-finder', 
-        details: { path, success: true } 
-      });
-    } catch (error) {
-      console.error("Show in finder error:", error);
-      this.onSystemEvent?.({ 
-        type: 'show-in-finder', 
-        details: { path, success: false, error: error.message } 
-      });
-      throw error;
-    }
-  }
-
-  // Event callbacks
-  onFileSelected?: (paths: string[]) => void;
-  onSystemEvent?: (event: { type: string; details: any }) => void;
-}
-
-export const fileManager = new FileManager();

package/templates/interactive-playground/src/bun/demos/menus.ts

@@ -1,139 +0,0 @@
-import { ApplicationMenu, ContextMenu, Tray } from "electrobun/bun";
-
-class MenuManager {
-  private trays = new Map<number, Tray>();
-  private nextTrayId = 1;
-
-  constructor() {
-    this.setupApplicationMenu();
-  }
-
-  private setupApplicationMenu() {
-    ApplicationMenu.setApplicationMenu([
-      {
-        submenu: [
-          { label: "About", role: "about" },
-          { type: "separator" },
-          { label: "Quit", role: "quit", accelerator: "q" }
-        ],
-      },
-      {
-        label: "Edit",
-        submenu: [
-          { role: "undo" },
-          { role: "redo" },
-          { type: "separator" },
-          {
-            label: "Custom Demo Action",
-            action: "demo-action",
-            tooltip: "This is a demo menu item",
-          },
-          { type: "separator" },
-          { role: "cut" },
-          { role: "copy" },
-          { role: "paste" },
-          { role: "selectAll" },
-        ],
-      },
-      {
-        label: "View",
-        submenu: [
-          { role: "reload" },
-          { role: "forceReload" },
-          { role: "toggleDevTools" },
-          { type: "separator" },
-          { role: "resetZoom" },
-          { role: "zoomIn" },
-          { role: "zoomOut" },
-          { type: "separator" },
-          { role: "togglefullscreen" }
-        ],
-      },
-      {
-        label: "Window",
-        submenu: [
-          { role: "minimize" },
-          { role: "close" }
-        ],
-      }
-    ]);
-  }
-
-  async createTray(options: { title: string; image?: string }) {
-    const id = this.nextTrayId++;
-    
-    const tray = new Tray({
-      title: options.title,
-      image: options.image || "views://assets/tray-icon.png",
-      template: true,
-      width: 32,
-      height: 32,
-    });
-
-    // Set up tray menu
-    tray.setMenu([
-      {
-        type: "normal",
-        label: "Show Playground",
-        action: "show-playground",
-      },
-      {
-        type: "separator",
-      },
-      {
-        type: "normal",
-        label: "Demo Action",
-        action: "demo-tray-action",
-        tooltip: "This is a demo tray action",
-      },
-      {
-        type: "normal",
-        label: "Quit",
-        action: "quit-app",
-      },
-    ]);
-
-    tray.on("tray-clicked", (e) => {
-      this.onTrayClicked?.(id, e.data.action);
-    });
-
-    this.trays.set(id, tray);
-    return { id };
-  }
-
-  async removeTray(id: number) {
-    const tray = this.trays.get(id);
-    if (tray) {
-      tray.remove();
-      this.trays.delete(id);
-    }
-  }
-
-  async showContextMenu(params: { x: number; y: number }) {
-    ContextMenu.showContextMenu([
-      { role: "undo" },
-      { role: "redo" },
-      { type: "separator" },
-      {
-        label: "Demo Context Action",
-        action: "demo-context-action",
-        tooltip: "This is a demo context menu item",
-      },
-      {
-        label: "Disabled Action",
-        action: "disabled-action",
-        enabled: false,
-      },
-      { type: "separator" },
-      { role: "cut" },
-      { role: "copy" },
-      { role: "paste" },
-    ]);
-  }
-
-  // Event callbacks
-  onTrayClicked?: (id: number, action: string) => void;
-  onMenuClicked?: (action: string) => void;
-}
-
-export const menuManager = new MenuManager();

package/templates/interactive-playground/src/bun/demos/rpc.ts

@@ -1,83 +0,0 @@
-class RPCTester {
-  async doMath(data: { a: number; b: number; operation: string }): Promise<number> {
-    const startTime = Date.now();
-    let result: number;
-
-    switch (data.operation) {
-      case 'add':
-        result = data.a + data.b;
-        break;
-      case 'subtract':
-        result = data.a - data.b;
-        break;
-      case 'multiply':
-        result = data.a * data.b;
-        break;
-      case 'divide':
-        if (data.b === 0) throw new Error("Division by zero");
-        result = data.a / data.b;
-        break;
-      case 'power':
-        result = Math.pow(data.a, data.b);
-        break;
-      default:
-        throw new Error(`Unknown operation: ${data.operation}`);
-    }
-
-    const duration = Date.now() - startTime;
-    
-    // Don't send notification here - let the frontend handle timing and display
-    // to avoid duplicate entries
-    
-    return result;
-  }
-
-  async echoBigData(data: string): Promise<string> {
-    const startTime = Date.now();
-    
-    // Simulate some processing time
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    const response = `Echo: ${data.slice(0, 100)}... (${data.length} chars)`;
-    const duration = Date.now() - startTime;
-    
-    // Don't send notification here - let the frontend handle timing and display
-    // to avoid duplicate entries
-
-    return response;
-  }
-
-  async performanceTest(messageSize: number, messageCount: number): Promise<{
-    totalTime: number;
-    averageTime: number;
-    messagesPerSecond: number;
-  }> {
-    const testData = "x".repeat(messageSize);
-    const results: number[] = [];
-
-    const startTime = Date.now();
-
-    for (let i = 0; i < messageCount; i++) {
-      const messageStart = Date.now();
-      await this.echoBigData(testData);
-      results.push(Date.now() - messageStart);
-    }
-
-    const totalTime = Date.now() - startTime;
-    const averageTime = results.reduce((a, b) => a + b, 0) / results.length;
-    const messagesPerSecond = (messageCount / totalTime) * 1000;
-
-    // Don't send notification here - let the frontend handle timing and display
-
-    return {
-      totalTime,
-      averageTime,
-      messagesPerSecond
-    };
-  }
-
-  // Event callbacks
-  onRpcTestResult?: (data: { operation: string; result: any; duration: number }) => void;
-}
-
-export const rpcTester = new RPCTester();

package/templates/interactive-playground/src/bun/demos/system.ts

@@ -1,72 +0,0 @@
-import Electrobun from "electrobun/bun";
-import { platform, arch, release } from "os";
-
-class SystemManager {
-  async getPlatformInfo() {
-    return {
-      platform: platform(),
-      arch: arch(),
-      version: release(),
-      electrobunVersion: "0.0.19-beta.118", // This should come from the actual API
-    };
-  }
-
-  async showNotification(options: {
-    title: string;
-    body: string;
-    icon?: string;
-  }) {
-    // Note: Notification API needs to be implemented in Electrobun
-    // For now, we'll simulate it
-    console.log("Notification:", options);
-    
-    this.onSystemEvent?.({
-      type: 'notification-shown',
-      details: {
-        title: options.title,
-        body: options.body,
-        timestamp: new Date().toISOString()
-      }
-    });
-
-    // In a real implementation, this would use the native notification system
-    return Promise.resolve();
-  }
-
-  async getClipboardText(): Promise<string> {
-    // Note: Clipboard API needs to be implemented in Electrobun
-    // This is a placeholder
-    return "Clipboard API not yet implemented";
-  }
-
-  async setClipboardText(text: string): Promise<void> {
-    // Note: Clipboard API needs to be implemented in Electrobun
-    console.log("Setting clipboard text:", text);
-    
-    this.onSystemEvent?.({
-      type: 'clipboard-set',
-      details: { text, timestamp: new Date().toISOString() }
-    });
-  }
-
-  async getScreenInfo() {
-    // Note: Screen API needs to be implemented in Electrobun
-    // This is a placeholder
-    return {
-      displays: [
-        {
-          id: 1,
-          width: 1920,
-          height: 1080,
-          scaleFactor: 1,
-          primary: true
-        }
-      ]
-    };
-  }
-
-  // Event callbacks
-  onSystemEvent?: (event: { type: string; details: any }) => void;
-}
-
-export const systemManager = new SystemManager();

package/templates/interactive-playground/src/bun/demos/updates.ts

@@ -1,105 +0,0 @@
-import Electrobun from "electrobun/bun";
-
-class UpdateManager {
-  async checkForUpdates() {
-    try {
-      const updateInfo = await Electrobun.Updater.checkForUpdate();
-      
-      this.onUpdateStatus?.({
-        status: 'checked',
-        progress: 100
-      });
-
-      return {
-        updateAvailable: updateInfo.updateAvailable,
-        currentVersion: Electrobun.Updater.getLocalVersion?.() || "0.0.19-beta.118",
-        latestVersion: updateInfo.latestVersion,
-      };
-    } catch (error) {
-      console.error("Update check error:", error);
-      
-      this.onUpdateStatus?.({
-        status: 'error',
-        progress: 0
-      });
-
-      return {
-        updateAvailable: false,
-        currentVersion: "0.0.19-beta.118",
-        error: error.message
-      };
-    }
-  }
-
-  async downloadUpdate() {
-    try {
-      this.onUpdateStatus?.({
-        status: 'downloading',
-        progress: 0
-      });
-
-      // Simulate download progress
-      for (let i = 0; i <= 100; i += 10) {
-        await new Promise(resolve => setTimeout(resolve, 200));
-        this.onUpdateStatus?.({
-          status: 'downloading',
-          progress: i
-        });
-      }
-
-      await Electrobun.Updater.downloadUpdate();
-      
-      this.onUpdateStatus?.({
-        status: 'downloaded',
-        progress: 100
-      });
-
-      return { success: true };
-    } catch (error) {
-      console.error("Update download error:", error);
-      
-      this.onUpdateStatus?.({
-        status: 'error',
-        progress: 0
-      });
-
-      return { success: false, error: error.message };
-    }
-  }
-
-  async applyUpdate() {
-    try {
-      this.onUpdateStatus?.({
-        status: 'applying',
-        progress: 50
-      });
-
-      await Electrobun.Updater.applyUpdate();
-      
-      this.onUpdateStatus?.({
-        status: 'applied',
-        progress: 100
-      });
-
-      return { success: true };
-    } catch (error) {
-      console.error("Update apply error:", error);
-      
-      this.onUpdateStatus?.({
-        status: 'error',
-        progress: 0
-      });
-
-      return { success: false, error: error.message };
-    }
-  }
-
-  getUpdateInfo() {
-    return Electrobun.Updater.updateInfo?.() || null;
-  }
-
-  // Event callbacks
-  onUpdateStatus?: (data: { status: string; progress?: number }) => void;
-}
-
-export const updateManager = new UpdateManager();

package/templates/interactive-playground/src/bun/demos/windows.ts

@@ -1,90 +0,0 @@
-import { BrowserWindow } from "electrobun/bun";
-
-class WindowManager {
-  private windows = new Map<number, BrowserWindow>();
-  private nextId = 1;
-
-  async createWindow(options: {
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-    frameless?: boolean;
-    transparent?: boolean;
-    alwaysOnTop?: boolean;
-  }) {
-    const id = this.nextId++;
-    
-    const window = new BrowserWindow({
-      title: `Demo Window ${id}`,
-      url: "views://mainview/index.html",
-      renderer: "cef",
-      frame: {
-        width: options.width,
-        height: options.height,
-        x: options.x,
-        y: options.y,
-      },
-      titleBarStyle: options.frameless ? "hiddenInset" : "default",
-      // For completely frameless, we need to set styleMask
-      styleMask: options.frameless ? {
-        Borderless: true,
-        Titled: false,
-        Closable: true,
-        Miniaturizable: true,
-        Resizable: true,
-      } : undefined,
-    });
-
-    this.windows.set(id, window);
-
-    // Listen for window events
-    window.on("close", () => {
-      this.windows.delete(id);
-      this.onWindowClosed?.(id);
-    });
-
-    window.on("resize", (event) => {
-      this.onWindowEvent?.({ type: 'resize', id, data: event.data });
-    });
-
-    window.on("move", (event) => {
-      this.onWindowEvent?.({ type: 'move', id, data: event.data });
-    });
-
-    this.onWindowCreated?.(id, `Demo Window ${id}`);
-    
-    return { id };
-  }
-
-  async closeWindow(id: number) {
-    const window = this.windows.get(id);
-    if (window) {
-      window.close();
-      this.windows.delete(id);
-    }
-  }
-
-  async focusWindow(id: number) {
-    const window = this.windows.get(id);
-    if (window) {
-      window.focus();
-      this.onWindowFocused?.(id);
-    }
-  }
-
-  async getWindowList() {
-    return Array.from(this.windows.entries()).map(([id, window]) => ({
-      id,
-      title: window.getTitle() || `Window ${id}`,
-    }));
-  }
-
-  // Event callbacks
-  onWindowCreated?: (id: number, title: string) => void;
-  onWindowClosed?: (id: number) => void;
-  onWindowFocused?: (id: number) => void;
-  onWindowEvent?: (event: { type: string; id: number; data: any }) => void;
-}
-
-export const windowManager = new WindowManager();

package/templates/interactive-playground/src/bun/index.ts

@@ -1,124 +0,0 @@
-import Electrobun, { BrowserWindow, BrowserView } from "electrobun/bun";
-import { type PlaygroundRPC } from "./types/rpc";
-
-// Import demo modules
-import { windowManager } from "./demos/windows";
-import { menuManager } from "./demos/menus";
-import { fileManager } from "./demos/files";
-import { rpcTester } from "./demos/rpc";
-
-console.log("🚀 Electrobun Interactive Playground starting...");
-
-// Set up RPC communication
-const rpc = BrowserView.defineRPC<PlaygroundRPC>({
-  maxRequestTime: 10000,
-  handlers: {
-    requests: {
-      // Window Management
-      createWindow: windowManager.createWindow.bind(windowManager),
-      closeWindow: windowManager.closeWindow.bind(windowManager),
-      focusWindow: windowManager.focusWindow.bind(windowManager),
-      getWindowList: windowManager.getWindowList.bind(windowManager),
-
-      // RPC Testing
-      doMath: rpcTester.doMath.bind(rpcTester),
-      echoBigData: rpcTester.echoBigData.bind(rpcTester),
-
-      // Menu Operations
-      createTray: menuManager.createTray.bind(menuManager),
-      removeTray: menuManager.removeTray.bind(menuManager),
-      showContextMenu: menuManager.showContextMenu.bind(menuManager),
-
-      // File Operations
-      openFileDialog: fileManager.openFileDialog.bind(fileManager),
-      moveToTrash: fileManager.moveToTrash.bind(fileManager),
-      showInFinder: fileManager.showInFinder.bind(fileManager),
-
-      // WebView Operations (placeholder)
-      createWebView: async (url: string) => ({ id: 1 }),
-      executeJSInWebView: async (params: { id: number; script: string }) => null,
-
-
-    },
-    messages: {
-      "*": (messageName, payload) => {
-        console.log(`📨 Message received: ${messageName}`, payload);
-      },
-    },
-  },
-});
-
-// Create main playground window
-const mainWindow = new BrowserWindow({
-  title: "Electrobun Interactive Playground",
-  url: "views://mainview/index.html",
-  renderer: "cef",
-  frame: {
-    width: 1400,
-    height: 900,
-    x: 100,
-    y: 100,
-  },
-  titleBarStyle: "default",
-  rpc,
-});
-
-// Set up event forwarding from demo modules to the UI
-windowManager.onWindowCreated = (id, title) => {
-  rpc.send.windowCreated({ id, title });
-};
-
-windowManager.onWindowClosed = (id) => {
-  rpc.send.windowClosed({ id });
-};
-
-windowManager.onWindowFocused = (id) => {
-  rpc.send.windowFocused({ id });
-};
-
-menuManager.onTrayClicked = (id, action) => {
-  rpc.send.trayClicked({ id, action });
-  console.log(`🔔 Tray ${id} clicked: ${action}`);
-};
-
-menuManager.onMenuClicked = (action) => {
-  rpc.send.menuClicked({ action });
-  console.log(`🎛️ Menu clicked: ${action}`);
-};
-
-fileManager.onFileSelected = (paths) => {
-  rpc.send.fileSelected({ paths });
-  console.log(`📁 Files selected:`, paths);
-};
-
-fileManager.onSystemEvent = (event) => {
-  rpc.send.systemEvent(event);
-  console.log(`⚙️ System event:`, event);
-};
-
-rpcTester.onRpcTestResult = (data) => {
-  rpc.send.rpcTestResult(data);
-  console.log(`📡 RPC test result:`, data);
-};
-
-
-
-// Listen for global events
-Electrobun.events.on("application-menu-clicked", (e) => {
-  menuManager.onMenuClicked?.(e.data.action);
-});
-
-Electrobun.events.on("context-menu-clicked", (e) => {
-  menuManager.onMenuClicked?.(e.data.action);
-});
-
-// Send initial status
-mainWindow.webview.on("dom-ready", () => {
-  console.log("✅ Main window DOM ready");
-  rpc.send.logMessage({ 
-    level: 'info', 
-    message: 'Electrobun Interactive Playground loaded successfully!' 
-  });
-});
-
-console.log("🎮 Playground initialized successfully");