refactor(main): organize main structure

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

Author: setchy

src/main/events.test.ts

@@ -25,40 +25,48 @@ describe('main/events', () => {
 
   it('onMainEvent registers ipcMain.on listener', () => {
     const listenerMock = vi.fn();
+
     onMainEvent(
       EVENTS.WINDOW_SHOW,
       listenerMock as unknown as (e: Electron.IpcMainEvent, d: unknown) => void,
     );
+
     expect(onMock).toHaveBeenCalledWith(EVENTS.WINDOW_SHOW, listenerMock);
   });
 
   it('handleMainEvent registers ipcMain.handle listener', () => {
     const listenerMock = vi.fn();
+
     handleMainEvent(
       EVENTS.VERSION,
       listenerMock as unknown as (
         e: Electron.IpcMainInvokeEvent,
         d: unknown,
       ) => void,
     );
+
     expect(handleMock).toHaveBeenCalledWith(EVENTS.VERSION, listenerMock);
   });
 
   it('sendRendererEvent forwards event to webContents with data', () => {
     const sendMock = vi.fn();
     const mb: MockMenubar = { window: { webContents: { send: sendMock } } };
+
     sendRendererEvent(
       mb as unknown as Menubar,
       EVENTS.UPDATE_ICON_TITLE,
       'title',
     );
+
     expect(sendMock).toHaveBeenCalledWith(EVENTS.UPDATE_ICON_TITLE, 'title');
   });
 
   it('sendRendererEvent forwards event without data', () => {
     const sendMock = vi.fn();
     const mb: MockMenubar = { window: { webContents: { send: sendMock } } };
+
     sendRendererEvent(mb as unknown as Menubar, EVENTS.RESET_APP);
+
     expect(sendMock).toHaveBeenCalledWith(EVENTS.RESET_APP, undefined);
   });
 });

src/main/events.ts

@@ -4,9 +4,11 @@ import type { Menubar } from 'menubar';
 import type { EventData, EventType } from '../shared/events';
 
 /**
- * Handle main event without expecting a response
- * @param event
- * @param listener
+ * Register a fire-and-forget IPC listener on the main process (ipcMain.on).
+ * Use this when the renderer sends a one-way message and no return value is needed.
+ *
+ * @param event - The IPC channel/event name to listen on.
+ * @param listener - Callback invoked when the event is received.
  */
 export function onMainEvent(
   event: EventType,
@@ -16,9 +18,11 @@ export function onMainEvent(
 }
 
 /**
- * Handle main event and return a response
- * @param event
- * @param listener
+ * Register a request/response IPC handler on the main process (ipcMain.handle).
+ * Use this when the renderer invokes a channel and expects a value back.
+ *
+ * @param event - The IPC channel/event name to handle.
+ * @param listener - Callback whose return value is sent back to the renderer.
  */
 export function handleMainEvent(
   event: EventType,
@@ -28,10 +32,11 @@ export function handleMainEvent(
 }
 
 /**
- * Send main event to renderer
- * @param mb the menubar instance
- * @param event the type of event to send
- * @param data the data to send with the event
+ * Push an event from the main process to the renderer via webContents.
+ *
+ * @param mb - The menubar instance whose window receives the event.
+ * @param event - The IPC channel/event name to emit.
+ * @param data - Optional payload sent with the event.
  */
 export function sendRendererEvent(
   mb: Menubar,

src/main/handlers/app.test.ts

@@ -37,23 +37,27 @@ describe('main/handlers/app.ts', () => {
     } 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);
+  describe('registerAppHandlers', () => {
+    it('registers handlers without throwing', () => {
+      expect(() => registerAppHandlers(menubar)).not.toThrow();
+    });
+
+    it('registers expected app IPC event 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/index.ts

@@ -0,0 +1,4 @@
+export * from './app';
+export * from './storage';
+export * from './system';
+export * from './tray';

src/main/handlers/storage.test.ts

@@ -24,18 +24,20 @@ describe('main/handlers/storage.ts', () => {
     vi.clearAllMocks();
   });
 
-  it('registers handlers without throwing', () => {
-    expect(() => registerStorageHandlers()).not.toThrow();
-  });
+  describe('registerStorageHandlers', () => {
+    it('registers handlers without throwing', () => {
+      expect(() => registerStorageHandlers()).not.toThrow();
+    });
 
-  it('registers SAFE_STORAGE_ENCRYPT and SAFE_STORAGE_DECRYPT handlers', () => {
-    registerStorageHandlers();
+    it('registers expected storage IPC event handlers', () => {
+      registerStorageHandlers();
 
-    const registeredHandlers = handleMock.mock.calls.map(
-      (call: [string]) => call[0],
-    );
+      const registeredHandlers = handleMock.mock.calls.map(
+        (call: [string]) => call[0],
+      );
 
-    expect(registeredHandlers).toContain(EVENTS.SAFE_STORAGE_ENCRYPT);
-    expect(registeredHandlers).toContain(EVENTS.SAFE_STORAGE_DECRYPT);
+      expect(registeredHandlers).toContain(EVENTS.SAFE_STORAGE_ENCRYPT);
+      expect(registeredHandlers).toContain(EVENTS.SAFE_STORAGE_DECRYPT);
+    });
   });
 });

src/main/handlers/system.test.ts

@@ -37,17 +37,21 @@ describe('main/handlers/system.ts', () => {
     } 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);
+  describe('registerSystemHandlers', () => {
+    it('registers handlers without throwing', () => {
+      expect(() => registerSystemHandlers(menubar)).not.toThrow();
+    });
+
+    it('registers expected system 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/tray.test.ts

@@ -31,19 +31,23 @@ describe('main/handlers/tray.ts', () => {
     } as unknown as Menubar;
   });
 
-  it('registers handlers without throwing', () => {
-    expect(() => registerTrayHandlers(menubar)).not.toThrow();
-  });
-
-  it('registers expected IPC event handlers', () => {
-    registerTrayHandlers(menubar);
-
-    const registeredEvents = onMock.mock.calls.map((call: [string]) => call[0]);
-
-    expect(registeredEvents).toContain(EVENTS.USE_ALTERNATE_IDLE_ICON);
-    expect(registeredEvents).toContain(EVENTS.USE_UNREAD_ACTIVE_ICON);
-    expect(registeredEvents).toContain(EVENTS.UPDATE_ICON_COLOR);
-    expect(registeredEvents).toContain(EVENTS.UPDATE_ICON_TITLE);
+  describe('registerTrayHandlers', () => {
+    it('registers handlers without throwing', () => {
+      expect(() => registerTrayHandlers(menubar)).not.toThrow();
+    });
+
+    it('registers expected tray IPC event handlers', () => {
+      registerTrayHandlers(menubar);
+
+      const registeredEvents = onMock.mock.calls.map(
+        (call: [string]) => call[0],
+      );
+
+      expect(registeredEvents).toContain(EVENTS.USE_ALTERNATE_IDLE_ICON);
+      expect(registeredEvents).toContain(EVENTS.USE_UNREAD_ACTIVE_ICON);
+      expect(registeredEvents).toContain(EVENTS.UPDATE_ICON_COLOR);
+      expect(registeredEvents).toContain(EVENTS.UPDATE_ICON_TITLE);
+    });
   });
 
   it('skips tray updates when tray is destroyed', () => {

src/main/handlers/tray.ts

@@ -9,6 +9,7 @@ import { TrayIcons } from '../icons';
 let shouldUseAlternateIdleIcon = false;
 let shouldUseUnreadActiveIcon = true;
 
+// TODO: Refactor to use ITrayColorUpdate type
 function setIdleIcon(mb: Menubar): void {
   if (shouldUseAlternateIdleIcon) {
     mb.tray.setImage(TrayIcons.idleAlternate);

src/main/icons.ts

@@ -9,5 +9,5 @@ export const TrayIcons = {
 };
 
 function getIconPath(iconName: string) {
-  return path.join(__dirname, '..', 'assets', 'images', iconName);
+  return path.resolve(__dirname, 'assets', 'images', iconName);
 }

src/main/index.ts

@@ -3,14 +3,19 @@ import log from 'electron-log';
 import { menubar } from 'menubar';
 
 import { Paths, WindowConfig } from './config';
-import { registerAppHandlers } from './handlers/app';
-import { registerStorageHandlers } from './handlers/storage';
-import { registerSystemHandlers } from './handlers/system';
-import { registerTrayHandlers } from './handlers/tray';
+import {
+  registerAppHandlers,
+  registerStorageHandlers,
+  registerSystemHandlers,
+  registerTrayHandlers,
+} from './handlers';
 import { TrayIcons } from './icons';
-import { onFirstRunMaybe } from './lifecycle/first-run';
-import { handleProtocolURL, initializeAppLifecycle } from './lifecycle/startup';
-import { configureWindowEvents } from './lifecycle/window';
+import {
+  configureWindowEvents,
+  handleProtocolURL,
+  initializeAppLifecycle,
+  onFirstRunMaybe,
+} from './lifecycle';
 import MenuBuilder from './menu';
 import AppUpdater from './updater';
 import { isDevMode } from './utils';