refactor(main): organize main structure

Signed-off-by: Adam Setch <adam.setch@outlook.com>

Author: setchy

src/main/config.test.ts

@@ -0,0 +1,39 @@
+import { Paths, WindowConfig } from './config';
+
+vi.mock('./utils', () => ({
+  isDevMode: vi.fn().mockReturnValue(false),
+}));
+
+vi.mock('electron', () => ({
+  app: {
+    isPackaged: true,
+  },
+}));
+
+describe('main/config.ts', () => {
+  it('exports Paths object with expected properties', () => {
+    expect(Paths.preload).toBeDefined();
+    expect(Paths.preload).toContain('preload.js');
+
+    expect(Paths.indexHtml).toBeDefined();
+    expect(Paths.indexHtml).toContain('index.html');
+
+    expect(Paths.notificationSound).toBeDefined();
+    expect(Paths.notificationSound).toContain('.mp3');
+
+    expect(Paths.twemojiFolder).toBeDefined();
+    expect(Paths.twemojiFolder).toContain('twemoji');
+  });
+
+  it('exports WindowConfig with expected properties', () => {
+    expect(WindowConfig.width).toBe(500);
+    expect(WindowConfig.height).toBe(400);
+    expect(WindowConfig.minWidth).toBe(500);
+    expect(WindowConfig.minHeight).toBe(400);
+    expect(WindowConfig.resizable).toBe(false);
+    expect(WindowConfig.skipTaskbar).toBe(true);
+    expect(WindowConfig.webPreferences).toBeDefined();
+    expect(WindowConfig.webPreferences.contextIsolation).toBe(true);
+    expect(WindowConfig.webPreferences.nodeIntegration).toBe(false);
+  });
+});

src/main/config.ts

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type { BrowserWindowConstructorOptions } from 'electron';
+
+import { APPLICATION } from '../shared/constants';
+
+import { isDevMode } from './utils';
+
+/**
+ * Resolved file-system and URL paths used throughout the main process.
+ */
+export const Paths = {
+  preload: path.resolve(__dirname, 'preload.js'),
+
+  get indexHtml(): string {
+    return isDevMode()
+      ? process.env.VITE_DEV_SERVER_URL || ''
+      : pathToFileURL(path.resolve(__dirname, 'index.html')).href;
+  },
+
+  get notificationSound(): string {
+    return pathToFileURL(
+      path.resolve(
+        __dirname,
+        'assets',
+        'sounds',
+        APPLICATION.NOTIFICATION_SOUND,
+      ),
+    ).href;
+  },
+
+  get twemojiFolder(): string {
+    return pathToFileURL(path.resolve(__dirname, 'assets', 'images', 'twemoji'))
+      .href;
+  },
+};
+
+/**
+ * Default browser window construction options for the menubar popup.
+ */
+export const WindowConfig: BrowserWindowConstructorOptions = {
+  width: 500,
+  height: 400,
+  minWidth: 500,
+  minHeight: 400,
+  resizable: false,
+  skipTaskbar: true, // Hide the app from the Windows taskbar
+  webPreferences: {
+    preload: Paths.preload,
+    contextIsolation: true,
+    nodeIntegration: false,
+    // Disable web security in development to allow CORS requests
+    webSecurity: !process.env.VITE_DEV_SERVER_URL,
+  },
+};

src/main/handlers/app.test.ts

@@ -0,0 +1,59 @@
+import type { Menubar } from 'menubar';
+
+import { EVENTS } from '../../shared/events';
+
+import { registerAppHandlers } from './app';
+
+const handleMock = vi.fn();
+const onMock = vi.fn();
+
+vi.mock('electron', () => ({
+  ipcMain: {
+    handle: (...args: unknown[]) => handleMock(...args),
+    on: (...args: unknown[]) => onMock(...args),
+  },
+  app: {
+    getVersion: vi.fn(() => '1.0.0'),
+  },
+}));
+
+vi.mock('../config', () => ({
+  Paths: {
+    notificationSound: 'file:///path/to/notification.wav',
+    twemojiFolder: 'file:///path/to/twemoji',
+  },
+}));
+
+describe('main/handlers/app.ts', () => {
+  let menubar: Menubar;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    menubar = {
+      showWindow: vi.fn(),
+      hideWindow: vi.fn(),
+      app: { quit: vi.fn() },
+    } as unknown as Menubar;
+  });
+
+  it('registers handlers without throwing', () => {
+    expect(() => registerAppHandlers(menubar)).not.toThrow();
+  });
+
+  it('registers VERSION, NOTIFICATION_SOUND_PATH, TWEMOJI_DIRECTORY, WINDOW_SHOW, WINDOW_HIDE, and QUIT handlers', () => {
+    registerAppHandlers(menubar);
+
+    const registeredHandlers = handleMock.mock.calls.map(
+      (call: [string]) => call[0],
+    );
+    const registeredEvents = onMock.mock.calls.map((call: [string]) => call[0]);
+
+    expect(registeredHandlers).toContain(EVENTS.VERSION);
+    expect(registeredHandlers).toContain(EVENTS.NOTIFICATION_SOUND_PATH);
+    expect(registeredHandlers).toContain(EVENTS.TWEMOJI_DIRECTORY);
+    expect(registeredEvents).toContain(EVENTS.WINDOW_SHOW);
+    expect(registeredEvents).toContain(EVENTS.WINDOW_HIDE);
+    expect(registeredEvents).toContain(EVENTS.QUIT);
+  });
+});

src/main/handlers/app.ts

@@ -0,0 +1,30 @@
+import { app } from 'electron';
+import type { Menubar } from 'menubar';
+
+import { EVENTS } from '../../shared/events';
+
+import { Paths } from '../config';
+import { handleMainEvent, onMainEvent } from '../events';
+
+/**
+ * Register IPC handlers for general application queries and window/app control.
+ *
+ * @param mb - The menubar instance used for window visibility and app quit control.
+ */
+export function registerAppHandlers(mb: Menubar): void {
+  handleMainEvent(EVENTS.VERSION, () => app.getVersion());
+
+  onMainEvent(EVENTS.WINDOW_SHOW, () => mb.showWindow());
+
+  onMainEvent(EVENTS.WINDOW_HIDE, () => mb.hideWindow());
+
+  onMainEvent(EVENTS.QUIT, () => mb.app.quit());
+
+  handleMainEvent(EVENTS.NOTIFICATION_SOUND_PATH, () => {
+    return Paths.notificationSound;
+  });
+
+  handleMainEvent(EVENTS.TWEMOJI_DIRECTORY, () => {
+    return Paths.twemojiFolder;
+  });
+}

src/main/handlers/storage.test.ts

@@ -0,0 +1,41 @@
+import { EVENTS } from '../../shared/events';
+
+import { registerStorageHandlers } from './storage';
+
+const handleMock = vi.fn();
+
+vi.mock('electron', () => ({
+  ipcMain: {
+    handle: (...args: unknown[]) => handleMock(...args),
+  },
+  safeStorage: {
+    encryptString: vi.fn((str: string) => Buffer.from(str)),
+    decryptString: vi.fn((buf: Buffer) => buf.toString()),
+  },
+}));
+
+const logErrorMock = vi.fn();
+vi.mock('../../shared/logger', () => ({
+  logError: (...args: unknown[]) => logErrorMock(...args),
+}));
+
+describe('main/handlers/storage.ts', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('registers handlers without throwing', () => {
+    expect(() => registerStorageHandlers()).not.toThrow();
+  });
+
+  it('registers SAFE_STORAGE_ENCRYPT and SAFE_STORAGE_DECRYPT handlers', () => {
+    registerStorageHandlers();
+
+    const registeredHandlers = handleMock.mock.calls.map(
+      (call: [string]) => call[0],
+    );
+
+    expect(registeredHandlers).toContain(EVENTS.SAFE_STORAGE_ENCRYPT);
+    expect(registeredHandlers).toContain(EVENTS.SAFE_STORAGE_DECRYPT);
+  });
+});

src/main/handlers/storage.ts

@@ -0,0 +1,34 @@
+import { safeStorage } from 'electron';
+
+import { EVENTS } from '../../shared/events';
+import { logError } from '../../shared/logger';
+
+import { handleMainEvent } from '../events';
+
+/**
+ * Register IPC handlers for OS-level safe storage operations.
+ */
+export function registerStorageHandlers(): void {
+  /**
+   * Encrypt a string using Electron's safeStorage and return the encrypted value as a base64 string.
+   */
+  handleMainEvent(EVENTS.SAFE_STORAGE_ENCRYPT, (_, value: string) => {
+    return safeStorage.encryptString(value).toString('base64');
+  });
+
+  /**
+   * Decrypt a base64-encoded string using Electron's safeStorage and return the decrypted value.
+   */
+  handleMainEvent(EVENTS.SAFE_STORAGE_DECRYPT, (_, value: string) => {
+    try {
+      return safeStorage.decryptString(Buffer.from(value, 'base64'));
+    } catch (err) {
+      logError(
+        'main:safe-storage-decrypt',
+        'Failed to decrypt value - data may be from old build',
+        err,
+      );
+      throw err;
+    }
+  });
+}

src/main/handlers/system.test.ts

@@ -0,0 +1,53 @@
+import type { Menubar } from 'menubar';
+
+import { EVENTS } from '../../shared/events';
+
+import { registerSystemHandlers } from './system';
+
+const onMock = vi.fn();
+
+vi.mock('electron', () => ({
+  ipcMain: {
+    on: (...args: unknown[]) => onMock(...args),
+  },
+  globalShortcut: {
+    register: vi.fn(),
+    unregister: vi.fn(),
+  },
+  app: {
+    setLoginItemSettings: vi.fn(),
+  },
+  shell: {
+    openExternal: vi.fn(),
+  },
+}));
+
+describe('main/handlers/system.ts', () => {
+  let menubar: Menubar;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    menubar = {
+      showWindow: vi.fn(),
+      hideWindow: vi.fn(),
+      window: {
+        isVisible: vi.fn().mockReturnValue(false),
+      },
+    } as unknown as Menubar;
+  });
+
+  it('registers handlers without throwing', () => {
+    expect(() => registerSystemHandlers(menubar)).not.toThrow();
+  });
+
+  it('registers expected IPC event handlers', () => {
+    registerSystemHandlers(menubar);
+
+    const registeredEvents = onMock.mock.calls.map((call: [string]) => call[0]);
+
+    expect(registeredEvents).toContain(EVENTS.OPEN_EXTERNAL);
+    expect(registeredEvents).toContain(EVENTS.UPDATE_KEYBOARD_SHORTCUT);
+    expect(registeredEvents).toContain(EVENTS.UPDATE_AUTO_LAUNCH);
+  });
+});

src/main/handlers/system.ts

@@ -0,0 +1,53 @@
+import { app, globalShortcut, shell } from 'electron';
+import type { Menubar } from 'menubar';
+
+import {
+  EVENTS,
+  type IAutoLaunch,
+  type IKeyboardShortcut,
+  type IOpenExternal,
+} from '../../shared/events';
+
+import { onMainEvent } from '../events';
+
+/**
+ * Register IPC handlers for OS-level system operations.
+ *
+ * @param mb - The menubar instance used for show/hide on keyboard shortcut activation.
+ */
+export function registerSystemHandlers(mb: Menubar): void {
+  /**
+   * Open the given URL in the user's default browser, with an option to activate the app.
+   */
+  onMainEvent(EVENTS.OPEN_EXTERNAL, (_, { url, activate }: IOpenExternal) =>
+    shell.openExternal(url, { activate }),
+  );
+
+  /**
+   * Register or unregister a global keyboard shortcut that toggles the menubar window visibility.
+   */
+  onMainEvent(
+    EVENTS.UPDATE_KEYBOARD_SHORTCUT,
+    (_, { enabled, keyboardShortcut }: IKeyboardShortcut) => {
+      if (!enabled) {
+        globalShortcut.unregister(keyboardShortcut);
+        return;
+      }
+
+      globalShortcut.register(keyboardShortcut, () => {
+        if (mb.window.isVisible()) {
+          mb.hideWindow();
+        } else {
+          mb.showWindow();
+        }
+      });
+    },
+  );
+
+  /**
+   * Update the application's auto-launch setting based on the provided configuration.
+   */
+  onMainEvent(EVENTS.UPDATE_AUTO_LAUNCH, (_, settings: IAutoLaunch) => {
+    app.setLoginItemSettings(settings);
+  });
+}