import { app, Menu, type MenuItemConstructorOptions } from 'electron';

const isMac = process.platform === 'darwin';

const template: MenuItemConstructorOptions[] = [
  // macOS owns the app menu (the bold app-name menu). It does not exist on
  // Windows/Linux, so only push it conditionally.
  ...(isMac
    ? [{
        label: app.name,
        submenu: [
          { role: 'about' as const },
          { type: 'separator' as const },
          { role: 'services' as const },
          { type: 'separator' as const },
          { role: 'hide' as const },
          { role: 'hideOthers' as const },
          { role: 'unhide' as const },
          { type: 'separator' as const },
          { role: 'quit' as const },
        ],
      }]
    : []),
  {
    label: 'File',
    submenu: [
      { label: 'Open…', accelerator: 'CmdOrCtrl+O', click: () => openFile() },
      // On Windows/Linux, Quit lives under File; on macOS it is in the app menu.
      isMac ? { role: 'close' } : { role: 'quit' },
    ],
  },
  { label: 'Edit', submenu: [{ role: 'undo' }, { role: 'redo' }, { type: 'separator' }, { role: 'cut' }, { role: 'copy' }, { role: 'paste' }] },
  { label: 'View', submenu: [{ role: 'reload' }, { role: 'toggleDevTools' }, { type: 'separator' }, { role: 'togglefullscreen' }] },
  { role: 'windowMenu' },
];

Menu.setApplicationMenu(Menu.buildFromTemplate(template));

import { Menu, BrowserWindow } from 'electron';

win.webContents.on('context-menu', (_e, params) => {
  const menu = Menu.buildFromTemplate([
    { label: 'Copy', role: 'copy', enabled: params.editFlags.canCopy },
    { label: 'Paste', role: 'paste', enabled: params.editFlags.canPaste },
    { type: 'separator' },
    { label: 'Inspect Element', click: () => win.webContents.inspectElement(params.x, params.y) },
  ]);
  menu.popup({ window: BrowserWindow.fromWebContents(win.webContents)! });
});

import { app, Tray, Menu, nativeImage } from 'electron';
import path from 'node:path';

let tray: Tray; // module-level: keep it alive

app.whenReady().then(() => {
  // macOS expects a small monochrome "template image" that the OS tints for
  // light/dark menu bars. Name it *Template.png and mark it as such.
  const icon = nativeImage.createFromPath(path.join(__dirname, 'trayTemplate.png'));
  if (process.platform === 'darwin') icon.setTemplateImage(true);

  tray = new Tray(icon);
  tray.setToolTip('My App');
  tray.setContextMenu(Menu.buildFromTemplate([
    { label: 'Show', click: () => showMainWindow() },
    { type: 'separator' },
    { role: 'quit' },
  ]));
});

import { app, globalShortcut } from 'electron';

app.whenReady().then(() => {
  const ok = globalShortcut.register('CommandOrControl+Shift+Space', () => toggleQuickWindow());
  if (!ok) console.warn('Hotkey already taken by another app');
});

app.on('will-quit', () => globalShortcut.unregisterAll());

import { dialog, BrowserWindow, Notification } from 'electron';

async function pickFile(win: BrowserWindow) {
  const { canceled, filePaths } = await dialog.showOpenDialog(win, {
    properties: ['openFile', 'multiSelections'],
    filters: [{ name: 'Images', extensions: ['png', 'jpg', 'webp'] }],
  });
  if (!canceled) return filePaths;
}

async function confirmDelete(win: BrowserWindow) {
  const { response } = await dialog.showMessageBox(win, {
    type: 'warning',
    buttons: ['Cancel', 'Delete'],
    defaultId: 0,
    cancelId: 0,
    message: 'Delete this file?',
  });
  return response === 1;
}

function notify() {
  if (Notification.isSupported()) {
    new Notification({ title: 'Export complete', body: 'Saved to Downloads' }).show();
  }
}

import { app } from 'electron';
import path from 'node:path';

if (process.defaultApp && process.argv.length >= 2) {
  app.setAsDefaultProtocolClient('myapp', process.execPath, [path.resolve(process.argv[1])]);
} else {
  app.setAsDefaultProtocolClient('myapp');
}

// Windows / Linux: the deep link comes as argv on the second instance.
const gotLock = app.requestSingleInstanceLock();
if (!gotLock) app.quit();
app.on('second-instance', (_e, argv) => {
  const url = argv.find((a) => a.startsWith('myapp://'));
  if (url) handleDeepLink(url);
  focusMainWindow();
});

// macOS: the OS fires open-url (may arrive before windows exist).
app.on('open-url', (event, url) => {
  event.preventDefault();
  handleDeepLink(url);
});

import { app, protocol, net } from 'electron';
import { pathToFileURL } from 'node:url';

protocol.registerSchemesAsPrivileged([
  { scheme: 'app', privileges: { standard: true, secure: true, supportFetchAPI: true } },
]);

app.whenReady().then(() => {
  protocol.handle('app', (request) => {
    const url = new URL(request.url);
    // Resolve under your app root only — reject path traversal.
    const filePath = safeResolve(APP_ROOT, url.pathname);
    return net.fetch(pathToFileURL(filePath).toString());
  });
});

app.on('open-file', (event, filePath) => {
  event.preventDefault();
  openDocument(filePath);
});

npm i -D @electron/rebuild
npx electron-rebuild -f -w better-sqlite3

import { powerMonitor, powerSaveBlocker, nativeTheme, systemPreferences } from 'electron';

powerMonitor.on('suspend', () => pauseSync());
powerMonitor.on('resume', () => resumeSync());
powerMonitor.on('on-battery', () => throttleBackgroundWork());

// Keep the machine awake during a long export.
const blockerId = powerSaveBlocker.start('prevent-app-suspension');
// …later: powerSaveBlocker.stop(blockerId);

// Follow the OS theme; flip with nativeTheme.themeSource = 'dark' | 'light' | 'system'.
nativeTheme.on('updated', () => applyTheme(nativeTheme.shouldUseDarkColors));

// Accent color (Windows / macOS).
const accent = systemPreferences.getAccentColor();

app.setLoginItemSettings({
  openAtLogin: true,
  openAsHidden: true, // macOS: start in the background
  args: ['--hidden'], // your app reads this to skip showing a window
});

// Unread badge — dock on macOS, taskbar overlay on Windows/Linux (Unity).
app.setBadgeCount(3);

// macOS dock menu.
if (process.platform === 'darwin') {
  app.dock?.setMenu(Menu.buildFromTemplate([{ label: 'New Window', click: newWindow }]));
}

// Taskbar progress (0..1), or -1 to clear; <0 hides, >1 shows indeterminate.
win.setProgressBar(0.6);

// Windows jump list.
app.setJumpList([
  { type: 'custom', name: 'Recent', items: [{ type: 'task', title: 'New Doc', program: process.execPath, args: '--new' }] },
]);