electrobun 0.0.19-beta.13 → 0.0.19-beta.130

package/dist/api/bun/core/Utils.ts

@@ -0,0 +1,48 @@
+import { ffi } from "../proc/native";
+
+// TODO: move this to a more appropriate namespace
+export const moveToTrash = (path: string) => {
+  return ffi.request.moveToTrash({ path });
+};
+
+export const showItemInFolder = (path: string) => {
+  return ffi.request.showItemInFolder({ path });
+};
+
+export const openFileDialog = async (
+  opts: {
+    startingFolder?: string;
+    allowedFileTypes?: string;
+    canChooseFiles?: boolean;
+    canChooseDirectory?: boolean;
+    allowsMultipleSelection?: boolean;
+  } = {}
+): Promise<string[]> => {
+  const optsWithDefault = {
+    ...{
+      startingFolder: "~/",
+      allowedFileTypes: "*",
+      canChooseFiles: true,
+      canChooseDirectory: true,
+      allowsMultipleSelection: true,
+    },
+    ...opts,
+  };
+
+  // todo: extend the timeout for this one (this version of rpc-anywhere doesn't seem to be able to set custom timeouts per request)
+  // we really want it to be infinity since the open file dialog blocks everything anyway.
+  // todo: there's the timeout between bun and zig, and the timeout between browser and bun since user likely requests
+  // from a browser context
+  const result = await ffi.request.openFileDialog({
+    startingFolder: optsWithDefault.startingFolder,
+    allowedFileTypes: optsWithDefault.allowedFileTypes,
+    canChooseFiles: optsWithDefault.canChooseFiles,
+    canChooseDirectory: optsWithDefault.canChooseDirectory,
+    allowsMultipleSelection: optsWithDefault.allowsMultipleSelection,
+  });
+
+  const filePaths = result.split(",");
+
+  // todo: it's nested like this due to zig union types. needs a zig refactor and revisit
+  return filePaths;
+};

package/dist/api/bun/events/ApplicationEvents.ts

@@ -0,0 +1,14 @@
+import ElectrobunEvent from "./event";
+
+export default {
+  applicationMenuClicked: (data) =>
+    new ElectrobunEvent<{ id: number; action: string }, { allow: boolean }>(
+      "application-menu-clicked",
+      data
+    ),
+  contextMenuClicked: (data) =>
+    new ElectrobunEvent<{ id: number; action: string }, { allow: boolean }>(
+      "context-menu-clicked",
+      data
+    ),
+};

package/dist/api/bun/events/event.ts

@@ -0,0 +1,29 @@
+export default class ElectrobunEvent<DataType, ResponseType> {
+    // todo (yoav): make most of these readonly except for response
+    name: string;
+    data: DataType;
+    // todo (yoav): define getters and setters for response
+    _response: ResponseType | undefined;
+    responseWasSet: boolean = false;
+
+    constructor(name: string, data: DataType) {
+        this.name = name;
+        this.data = data;
+    }
+
+      // Getter for response
+      get response(): ResponseType | undefined {
+        return this._response;
+    }
+
+    // Setter for response
+    set response(value: ResponseType) {
+        this._response = value;
+        this.responseWasSet = true; // Update flag when response is set
+    }
+
+    clearResponse() {
+        this._response = undefined;
+        this.responseWasSet = false;
+    }
+}

package/dist/api/bun/events/eventEmitter.ts

@@ -0,0 +1,45 @@
+import EventEmitter from "events";
+import windowEvents from "./windowEvents";
+import webviewEvents from "./webviewEvents";
+import trayEvents from "./trayEvents";
+import applicationEvents from "./ApplicationEvents";
+import ElectrobunEvent from "./event";
+
+class ElectrobunEventEmitter extends EventEmitter {
+  constructor() {
+    super();
+  }
+
+  // optionally pass in a specifier to make the event name specific.
+  // eg: will-navigate is listened to globally for all webviews, but
+  // will-navigate-1 is listened to for a specific webview with id 1
+  emitEvent(
+    ElectrobunEvent: ElectrobunEvent<any, any>,
+    specifier?: number | string
+  ) {
+    if (specifier) {
+      this.emit(`${ElectrobunEvent.name}-${specifier}`, ElectrobunEvent);
+    } else {
+      this.emit(ElectrobunEvent.name, ElectrobunEvent);
+    }
+  }
+
+  events = {
+    window: {
+      ...windowEvents,
+    },
+    webview: {
+      ...webviewEvents,
+    },
+    tray: {
+      ...trayEvents,
+    },
+    app: {
+      ...applicationEvents,
+    },
+  };
+}
+
+export const electrobunEventEmitter = new ElectrobunEventEmitter();
+
+export default electrobunEventEmitter;

package/dist/api/bun/events/trayEvents.ts

@@ -0,0 +1,9 @@
+import ElectrobunEvent from "./event";
+
+export default {
+  trayClicked: (data) =>
+    new ElectrobunEvent<{ id: number; action: string }, { allow: boolean }>(
+      "tray-clicked",
+      data
+    ),
+};

package/dist/api/bun/events/webviewEvents.ts

@@ -0,0 +1,16 @@
+import ElectrobunEvent from "./event";
+
+export default {
+  willNavigate: (data) =>
+    new ElectrobunEvent<{ detail: string }, {}>("will-navigate", data),
+  didNavigate: (data) =>
+    new ElectrobunEvent<{ detail: string }, {}>("did-navigate", data),
+  didNavigateInPage: (data) =>
+    new ElectrobunEvent<{ detail: string }, {}>("did-navigate-in-page", data),
+  didCommitNavigation: (data) =>
+    new ElectrobunEvent<{ detail: string }, {}>("did-commit-navigation", data),
+  domReady: (data) =>
+    new ElectrobunEvent<{ detail: string }, {}>("dom-ready", data),
+  newWindowOpen: (data) =>
+    new ElectrobunEvent<{ detail: string }, {}>("new-window-open", data),
+};

package/dist/api/bun/events/windowEvents.ts

@@ -0,0 +1,12 @@
+import ElectrobunEvent from "./event";
+
+export default {
+  close: (data) => new ElectrobunEvent<{ id: number }, {}>("close", data),
+  resize: (data) =>
+    new ElectrobunEvent<
+      { id: number; x: number; y: number; width: number; height: number },
+      {}
+    >("resize", data),
+  move: (data) =>
+    new ElectrobunEvent<{ id: number; x: number; y: number }, {}>("move", data),
+};

package/dist/api/bun/index.ts

@@ -0,0 +1,47 @@
+import electobunEventEmmitter from "./events/eventEmitter";
+import { BrowserWindow } from "./core/BrowserWindow";
+import { BrowserView } from "./core/BrowserView";
+import { Tray } from "./core/Tray";
+import * as ApplicationMenu from "./core/ApplicationMenu";
+import * as ContextMenu from "./core/ContextMenu";
+import { Updater } from "./core/Updater";
+import * as Utils from "./core/Utils";
+import { type RPCSchema, createRPC } from "rpc-anywhere";
+import type ElectrobunEvent from "./events/event";
+import * as PATHS from "./core/Paths";
+import * as Socket from "./core/Socket";
+import type { ElectrobunConfig } from "./ElectrobunConfig";
+
+// Named Exports
+export {
+  type RPCSchema,
+  type ElectrobunEvent,
+  type ElectrobunConfig,
+  createRPC,
+  BrowserWindow,
+  BrowserView,
+  Tray,
+  Updater,
+  Utils,
+  ApplicationMenu,
+  ContextMenu,
+  PATHS,
+  Socket,
+};
+
+// Default Export
+const Electrobun = {
+  BrowserWindow,
+  BrowserView,
+  Tray,
+  Updater,
+  Utils,
+  ApplicationMenu,
+  ContextMenu,
+  events: electobunEventEmmitter,
+  PATHS,
+  Socket,
+};
+
+// Electrobun
+export default Electrobun;

package/dist/api/bun/proc/linux.md

@@ -0,0 +1,43 @@
+
+## Linux System Tray Support
+
+System tray functionality on Linux requires a compatible desktop environment or additional packages. Many modern Linux distributions (especially those using GNOME 3.26+) don't display system trays by default.
+
+### Installation Instructions by Desktop Environment
+
+You probably need to tell users to install whatever system tray thing works on their linux distro or whatever.
+
+**For Unity:**
+```bash
+# Install indicator support
+sudo apt install indicator-application
+
+```
+
+**For KDE Plasma, XFCE, MATE, Cinnamon:**
+- System tray support works out of the box, no additional installation needed
+
+### Alternative Installation Method
+
+You can also install the GNOME extension through your web browser:
+1. Visit https://extensions.gnome.org/extension/615/appindicator-support/
+2. Install the browser extension if prompted
+3. Click the toggle to enable the extension
+
+### Verifying Installation
+
+After installation and restart, system tray icons should appear in your top panel (usually top-right corner). If the tray still doesn't appear, your application will continue to function normally without tray support.
+
+### Note for Application Developers
+
+When distributing Electrobun applications that use system tray:
+- Document the system tray requirements for GNOME users
+- Consider providing alternative UI access to tray functionality
+- The tray implementation gracefully handles environments where system tray is unavailable
+
+
+### Application menus
+The standard file, edit, etc. menus are super jank and would complicated the complex OOPIF compositing we do on gtk windows and x11 so on linux they're not wired up. You can get the same functionality by just using html in your webview to make a menu like interface and rpc to bun.
+
+### Context menus
+Likewise the showContextMenu functionality that works on mac to show an arbitrary context menu wherever the mouse is (regardless of what it's over or what app is focused) is just not a ux linux supports well so that's also a noop on linux