Utils

import {Utils} from "electrobun/bun";

Utils.moveToTrash(absolutePath)

Utils.showItemInFolder(absolutePath)

// Open a website in the default browser
Utils.openExternal("https://example.com");

// Open an email compose window
Utils.openExternal("mailto:[email protected]?subject=Help");

// Open a custom URL scheme (if registered)
Utils.openExternal("slack://open");

// Open with file:// protocol
Utils.openExternal("file:///Users/me/Documents/report.pdf");

// Open a PDF with the default PDF reader
Utils.openPath("/Users/me/Documents/report.pdf");

// Open an image with the default image viewer
Utils.openPath("/Users/me/Pictures/photo.jpg");

// Open a folder in the file manager
Utils.openPath("/Users/me/Downloads");

// Open a text file with the default text editor
Utils.openPath("/Users/me/notes.txt");

Utils.showNotification({
    title: "Download Complete"
});

Utils.showNotification({
    title: "New Message",
    body: "You have a new message from John"
});

Utils.showNotification({
    title: "Reminder",
    subtitle: "Calendar Event",
    body: "Team meeting in 15 minutes",
    silent: false
});

Utils.showNotification({
    title: "Sync Complete",
    body: "All files have been synchronized",
    silent: true
});

// To simplify this example we'll just show a dialogue after a 2 second timeout

setTimeout(async () => {

    const chosenPaths = await Utils.openFileDialog({
        startingFolder: join(homedir(), "Desktop"),
        allowedFileTypes: "*",
        // allowedFileTypes: "png,jpg",
        canChooseFiles: true,
        canChooseDirectory: false,
        allowsMultipleSelection: true,
    });

    console.log("chosen paths", chosenPaths);
 }, 2000);

const { response } = await Utils.showMessageBox({
    type: "question",
    title: "Confirm Delete",
    message: "Are you sure you want to delete this file?",
    detail: "This action cannot be undone.",
    buttons: ["Delete", "Cancel"],
    defaultId: 1,  // Focus "Cancel" by default
    cancelId: 1    // Pressing Escape returns 1 (Cancel)
});

if (response === 0) {
    // User clicked "Delete"
    console.log("Deleting file...");
} else {
    // User clicked "Cancel" or closed the dialog
    console.log("Cancelled");
}

await Utils.showMessageBox({
    type: "error",
    title: "Error",
    message: "Failed to save file",
    detail: "The disk may be full or you may not have write permissions.",
    buttons: ["OK"]
});

const { response } = await Utils.showMessageBox({
    type: "warning",
    title: "Unsaved Changes",
    message: "You have unsaved changes.",
    detail: "What would you like to do?",
    buttons: ["Save", "Don't Save", "Cancel"],
    defaultId: 0,
    cancelId: 2
});

switch (response) {
    case 0: saveAndClose(); break;
    case 1: closeWithoutSaving(); break;
    case 2: /* cancelled */ break;
}

Utils.quit()

// The quit can be cancelled via the before-quit event
Electrobun.events.on("before-quit", (e) => {
  if (hasUnsavedChanges()) {
    e.response = { allow: false };
  }
});

const text = Utils.clipboardReadText();
if (text) {
    console.log("Clipboard contains:", text);
}

Utils.clipboardWriteText("Hello from Electrobun!");

const pngData = Utils.clipboardReadImage();
if (pngData) {
    // Write to file
    await Bun.write("clipboard-image.png", pngData);
    console.log("Saved clipboard image:", pngData.length, "bytes");
}

// Read a PNG file and write to clipboard
const pngData = await Bun.file("image.png").arrayBuffer();
Utils.clipboardWriteImage(new Uint8Array(pngData));

Utils.clipboardClear();

const formats = Utils.clipboardAvailableFormats();
console.log("Clipboard contains:", formats);
// Possible values: ["text", "image", "files", "html"]

// Copy text to clipboard
Utils.clipboardWriteText("Hello World");

// Later, read it back
const text = Utils.clipboardReadText();
console.log(text); // "Hello World"

const formats = Utils.clipboardAvailableFormats();

if (formats.includes("text")) {
    const text = Utils.clipboardReadText();
    console.log("Text:", text);
}

if (formats.includes("image")) {
    const imageData = Utils.clipboardReadImage();
    console.log("Image size:", imageData?.length, "bytes");
}

import { Utils } from "electrobun/bun";

console.log(Utils.paths.home);      // Home directory
console.log(Utils.paths.downloads); // Downloads folder
console.log(Utils.paths.userData);  // App-specific data directory

Utils.paths.home
// macOS:   ~
// Windows: %USERPROFILE%
// Linux:   ~

Utils.paths.appData
// macOS:   ~/Library/Application Support
// Windows: %LOCALAPPDATA%
// Linux:   $XDG_DATA_HOME or ~/.local/share

Utils.paths.config
// macOS:   ~/Library/Application Support
// Windows: %APPDATA%
// Linux:   $XDG_CONFIG_HOME or ~/.config

Utils.paths.cache
// macOS:   ~/Library/Caches
// Windows: %LOCALAPPDATA%
// Linux:   $XDG_CACHE_HOME or ~/.cache

Utils.paths.temp
// macOS:   $TMPDIR
// Windows: %TEMP%
// Linux:   /tmp

Utils.paths.logs
// macOS:   ~/Library/Logs
// Windows: %LOCALAPPDATA%
// Linux:   $XDG_STATE_HOME or ~/.local/state

Utils.paths.documents
// macOS:   ~/Documents
// Windows: %USERPROFILE%\Documents
// Linux:   $XDG_DOCUMENTS_DIR or ~/Documents

Utils.paths.downloads
// macOS:   ~/Downloads
// Windows: %USERPROFILE%\Downloads
// Linux:   $XDG_DOWNLOAD_DIR or ~/Downloads

Utils.paths.desktop
// macOS:   ~/Desktop
// Windows: %USERPROFILE%\Desktop
// Linux:   $XDG_DESKTOP_DIR or ~/Desktop

Utils.paths.pictures
// macOS:   ~/Pictures
// Windows: %USERPROFILE%\Pictures
// Linux:   $XDG_PICTURES_DIR or ~/Pictures

Utils.paths.music
// macOS:   ~/Music
// Windows: %USERPROFILE%\Music
// Linux:   $XDG_MUSIC_DIR or ~/Music

Utils.paths.videos
// macOS:   ~/Movies
// Windows: %USERPROFILE%\Videos
// Linux:   $XDG_VIDEOS_DIR or ~/Videos

Utils.paths.userData   // {appData}/{identifier}/{channel}
Utils.paths.userCache  // {cache}/{identifier}/{channel}
Utils.paths.userLogs   // {logs}/{identifier}/{channel}

// Example: app with identifier "com.mycompany.myapp", channel "canary", on macOS:
Utils.paths.userData   // ~/Library/Application Support/com.mycompany.myapp/canary
Utils.paths.userCache  // ~/Library/Caches/com.mycompany.myapp/canary
Utils.paths.userLogs   // ~/Library/Logs/com.mycompany.myapp/canary

import { Utils } from "electrobun/bun";
import { join } from "path";
import { mkdirSync, writeFileSync, readFileSync } from "fs";

// Ensure the directory exists
mkdirSync(Utils.paths.userData, { recursive: true });

// Write a settings file
const settingsPath = join(Utils.paths.userData, "settings.json");
writeFileSync(settingsPath, JSON.stringify({ theme: "dark" }));

// Read it back
const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));

import { Utils } from "electrobun/bun";
import { join } from "path";

const savePath = join(Utils.paths.downloads, "report.pdf");
await Bun.write(savePath, pdfData);

import { GlobalShortcut } from "electrobun/bun";

const success = GlobalShortcut.register("CommandOrControl+Shift+Space", () => {
    console.log("Global shortcut triggered!");
    // Show your app, toggle a feature, etc.
});

if (!success) {
    console.log("Failed to register shortcut (may already be in use)");
}

GlobalShortcut.unregister("CommandOrControl+Shift+Space");

GlobalShortcut.unregisterAll();

if (GlobalShortcut.isRegistered("CommandOrControl+Shift+Space")) {
    console.log("Shortcut is active");
}

import { GlobalShortcut, BrowserWindow } from "electrobun/bun";

// Register a shortcut to show/hide the main window
GlobalShortcut.register("CommandOrControl+Shift+H", () => {
    const win = BrowserWindow.getById(1);
    if (win) {
        // Toggle visibility
        if (win.isVisible()) {
            win.hide();
        } else {
            win.show();
            win.focus();
        }
    }
});

import { Screen } from "electrobun/bun";

interface Rectangle {
  x: number;
  y: number;
  width: number;
  height: number;
}

interface Display {
  id: number;           // Unique display identifier
  bounds: Rectangle;    // Full screen bounds
  workArea: Rectangle;  // Available area (excludes dock/taskbar/menu bar)
  scaleFactor: number;  // DPI scale (e.g., 2.0 for Retina/HiDPI)
  isPrimary: boolean;   // Whether this is the primary display
}

interface Point {
  x: number;
  y: number;
}

const primary = Screen.getPrimaryDisplay();
console.log(`Primary display: ${primary.bounds.width}x${primary.bounds.height}`);
console.log(`Scale factor: ${primary.scaleFactor}x`);
console.log(`Work area: ${primary.workArea.width}x${primary.workArea.height}`);

const displays = Screen.getAllDisplays();
console.log(`Found ${displays.length} display(s)`);

displays.forEach((display, index) => {
  console.log(`Display ${index}: ${display.bounds.width}x${display.bounds.height}`);
  console.log(`  Position: (${display.bounds.x}, ${display.bounds.y})`);
  console.log(`  Scale: ${display.scaleFactor}x`);
  console.log(`  Primary: ${display.isPrimary}`);
});

const cursor = Screen.getCursorScreenPoint();
console.log(`Cursor at: (${cursor.x}, ${cursor.y})`);

import { Screen, BrowserWindow } from "electrobun/bun";

const primary = Screen.getPrimaryDisplay();
const windowWidth = 800;
const windowHeight = 600;

// Calculate centered position
const x = Math.round((primary.workArea.width - windowWidth) / 2) + primary.workArea.x;
const y = Math.round((primary.workArea.height - windowHeight) / 2) + primary.workArea.y;

const win = new BrowserWindow({
  title: "Centered Window",
  url: "views://mainview/index.html",
  frame: {
    width: windowWidth,
    height: windowHeight,
    x: x,
    y: y,
  },
});

import { Screen, BrowserWindow } from "electrobun/bun";

function getDisplayAtCursor() {
  const cursor = Screen.getCursorScreenPoint();
  const displays = Screen.getAllDisplays();

  return displays.find(display => {
    const { x, y, width, height } = display.bounds;
    return cursor.x >= x && cursor.x < x + width &&
           cursor.y >= y && cursor.y < y + height;
  }) || Screen.getPrimaryDisplay();
}

const targetDisplay = getDisplayAtCursor();
console.log(`Opening window on display: ${targetDisplay.id}`);

import { Session } from "electrobun/bun";

interface Cookie {
  name: string;
  value: string;
  domain?: string;
  path?: string;
  secure?: boolean;
  httpOnly?: boolean;
  sameSite?: 'no_restriction' | 'lax' | 'strict';
  expirationDate?: number; // Unix timestamp in seconds
}

interface CookieFilter {
  url?: string;
  name?: string;
  domain?: string;
  path?: string;
  secure?: boolean;
  session?: boolean;
}

type StorageType =
  | 'cookies'
  | 'localStorage'
  | 'sessionStorage'
  | 'indexedDB'
  | 'webSQL'
  | 'cache'
  | 'all';

// Persistent session (survives app restarts)
const session = Session.fromPartition("persist:myapp");

// Ephemeral session (cleared when app closes)
const tempSession = Session.fromPartition("temp");

const session = Session.defaultSession;
console.log(session.partition); // "persist:default"

const session = Session.fromPartition("persist:myapp");

// Get all cookies
const allCookies = session.cookies.get();
console.log(`Found ${allCookies.length} cookies`);

// Get cookies by name
const authCookies = session.cookies.get({ name: "auth_token" });

// Get cookies by domain
const domainCookies = session.cookies.get({ domain: "example.com" });

// Get cookies by URL
const urlCookies = session.cookies.get({ url: "https://api.example.com" });

const session = Session.fromPartition("persist:myapp");

// Set a basic cookie
session.cookies.set({
  name: "user_id",
  value: "12345",
  domain: "myapp.com",
  path: "/"
});

// Set a secure cookie with expiration
session.cookies.set({
  name: "auth_token",
  value: "abc123xyz",
  domain: "api.myapp.com",
  path: "/",
  secure: true,
  httpOnly: true,
  sameSite: "strict",
  expirationDate: Math.floor(Date.now() / 1000) + (7 * 24 * 60 * 60) // 7 days
});

const session = Session.fromPartition("persist:myapp");

// Remove a specific cookie
session.cookies.remove("https://myapp.com", "user_id");

const session = Session.fromPartition("persist:myapp");

// Clear all cookies
session.cookies.clear();

const session = Session.fromPartition("persist:myapp");

// Clear all storage
session.clearStorageData();

// Clear specific storage types
session.clearStorageData(['cookies', 'localStorage']);

// Clear just the cache
session.clearStorageData(['cache']);

import { Session } from "electrobun/bun";

function logout() {
  const session = Session.fromPartition("persist:user");

  // Clear auth cookies
  session.cookies.remove("https://api.myapp.com", "auth_token");
  session.cookies.remove("https://api.myapp.com", "refresh_token");

  // Clear local storage data
  session.clearStorageData(['localStorage', 'sessionStorage']);

  console.log("User logged out");
}

import { Session, BrowserWindow } from "electrobun/bun";

// Create a webview with its own session
function createAccountWindow(accountId: string) {
  const partition = `persist:account-${accountId}`;
  const session = Session.fromPartition(partition);

  // Each account has isolated cookies/storage
  const win = new BrowserWindow({
    title: `Account: ${accountId}`,
    url: "https://myapp.com/dashboard",
    partition: partition,
    frame: { width: 800, height: 600, x: 100, y: 100 }
  });

  return { window: win, session };
}