Switch to double quotes and reformat codebase with Biome

packages/desktop/src/window/window-drag-coordinates.test.ts

@@ -1,71 +1,73 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it } from "vitest";
 
 import {
   createWindowMoveState,
   readWindowMovePayload,
   resolveWindowMovePosition,
-} from './window-drag-coordinates'
+} from "./window-drag-coordinates";
 
-describe('window-drag-coordinates', () => {
-  describe('readWindowMovePayload', () => {
-    it('returns finite screen coordinates', () => {
+describe("window-drag-coordinates", () => {
+  describe("readWindowMovePayload", () => {
+    it("returns finite screen coordinates", () => {
       expect(readWindowMovePayload({ screenX: 1500, screenY: 900 })).toEqual({
         screenX: 1500,
         screenY: 900,
-      })
-    })
+      });
+    });
 
-    it('rejects non-finite screen coordinates', () => {
-      expect(readWindowMovePayload({ screenX: Number.NaN, screenY: 900 })).toBeNull()
-      expect(readWindowMovePayload({ screenX: 1500, screenY: Number.POSITIVE_INFINITY })).toBeNull()
-    })
-  })
+    it("rejects non-finite screen coordinates", () => {
+      expect(readWindowMovePayload({ screenX: Number.NaN, screenY: 900 })).toBeNull();
+      expect(
+        readWindowMovePayload({ screenX: 1500, screenY: Number.POSITIVE_INFINITY }),
+      ).toBeNull();
+    });
+  });
 
-  describe('createWindowMoveState', () => {
-    it('derives finite offsets from the window position', () => {
+  describe("createWindowMoveState", () => {
+    it("derives finite offsets from the window position", () => {
       expect(
         createWindowMoveState({
           payload: { screenX: 1500, screenY: 900 },
           windowX: 1200,
           windowY: 700,
-        })
+        }),
       ).toEqual({
         offsetX: 300,
         offsetY: 200,
-      })
-    })
+      });
+    });
 
-    it('rejects non-finite offsets', () => {
+    it("rejects non-finite offsets", () => {
       expect(
         createWindowMoveState({
           payload: { screenX: 1500, screenY: 900 },
           windowX: Number.NaN,
           windowY: 700,
-        })
-      ).toBeNull()
-    })
-  })
+        }),
+      ).toBeNull();
+    });
+  });
 
-  describe('resolveWindowMovePosition', () => {
-    it('rounds the next window position', () => {
+  describe("resolveWindowMovePosition", () => {
+    it("rounds the next window position", () => {
       expect(
         resolveWindowMovePosition({
           payload: { screenX: 1501.4, screenY: 902.6 },
           state: { offsetX: 300, offsetY: 200 },
-        })
+        }),
       ).toEqual({
         x: 1201,
         y: 703,
-      })
-    })
+      });
+    });
 
-    it('rejects non-finite next positions', () => {
+    it("rejects non-finite next positions", () => {
       expect(
         resolveWindowMovePosition({
           payload: { screenX: 1500, screenY: 900 },
           state: { offsetX: Number.NaN, offsetY: 200 },
-        })
-      ).toBeNull()
-    })
-  })
-})
+        }),
+      ).toBeNull();
+    });
+  });
+});

packages/desktop/src/window/window-drag-coordinates.ts

@@ -1,64 +1,64 @@
 export type WindowMovePayload = {
-  screenX: number
-  screenY: number
-}
+  screenX: number;
+  screenY: number;
+};
 
 export type WindowMoveState = {
-  offsetX: number
-  offsetY: number
-}
+  offsetX: number;
+  offsetY: number;
+};
 
 export type WindowPosition = {
-  x: number
-  y: number
-}
+  x: number;
+  y: number;
+};
 
 type WindowMovePayloadInput =
   | {
-      screenX?: unknown
-      screenY?: unknown
+      screenX?: unknown;
+      screenY?: unknown;
     }
   | null
-  | undefined
+  | undefined;
 
 function isFiniteCoordinate(value: unknown): value is number {
-  return typeof value === 'number' && Number.isFinite(value)
+  return typeof value === "number" && Number.isFinite(value);
 }
 
 export function readWindowMovePayload(input: WindowMovePayloadInput): WindowMovePayload | null {
   if (!isFiniteCoordinate(input?.screenX) || !isFiniteCoordinate(input?.screenY)) {
-    return null
+    return null;
   }
 
   return {
     screenX: input.screenX,
     screenY: input.screenY,
-  }
+  };
 }
 
 export function createWindowMoveState(input: {
-  payload: WindowMovePayload
-  windowX: number
-  windowY: number
+  payload: WindowMovePayload;
+  windowX: number;
+  windowY: number;
 }): WindowMoveState | null {
-  const offsetX = input.payload.screenX - input.windowX
-  const offsetY = input.payload.screenY - input.windowY
+  const offsetX = input.payload.screenX - input.windowX;
+  const offsetY = input.payload.screenY - input.windowY;
   if (!Number.isFinite(offsetX) || !Number.isFinite(offsetY)) {
-    return null
+    return null;
   }
 
-  return { offsetX, offsetY }
+  return { offsetX, offsetY };
 }
 
 export function resolveWindowMovePosition(input: {
-  payload: WindowMovePayload
-  state: WindowMoveState
+  payload: WindowMovePayload;
+  state: WindowMoveState;
 }): WindowPosition | null {
-  const x = Math.round(input.payload.screenX - input.state.offsetX)
-  const y = Math.round(input.payload.screenY - input.state.offsetY)
+  const x = Math.round(input.payload.screenX - input.state.offsetX);
+  const y = Math.round(input.payload.screenY - input.state.offsetY);
   if (!Number.isFinite(x) || !Number.isFinite(y)) {
-    return null
+    return null;
   }
 
-  return { x, y }
+  return { x, y };
 }

packages/desktop/src/window/window-manager.ts

@@ -1,103 +1,103 @@
-import { app, BrowserWindow, ipcMain } from 'electron'
+import { app, BrowserWindow, ipcMain } from "electron";
 import {
   createWindowMoveState,
   readWindowMovePayload,
   resolveWindowMovePosition,
   type WindowMoveState,
-} from './window-drag-coordinates.js'
+} from "./window-drag-coordinates.js";
 
 export function registerWindowManager(): void {
   // ---------------------------------------------------------------------------
   // Manual window dragging (replaces flaky CSS -webkit-app-region: drag).
   // State is keyed per window id to support multiple windows.
   // ---------------------------------------------------------------------------
-  const moveStates = new Map<number, WindowMoveState>()
+  const moveStates = new Map<number, WindowMoveState>();
 
-  ipcMain.on('paseo:window:startMove', (event, payload: { screenX: number; screenY: number }) => {
-    const win = BrowserWindow.fromWebContents(event.sender)
-    if (!win) return
-    const movePayload = readWindowMovePayload(payload)
+  ipcMain.on("paseo:window:startMove", (event, payload: { screenX: number; screenY: number }) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (!win) return;
+    const movePayload = readWindowMovePayload(payload);
     if (!movePayload) {
-      moveStates.delete(win.id)
-      return
+      moveStates.delete(win.id);
+      return;
     }
-    const [winX, winY] = win.getPosition()
+    const [winX, winY] = win.getPosition();
     const moveState = createWindowMoveState({
       payload: movePayload,
       windowX: winX,
       windowY: winY,
-    })
+    });
     if (!moveState) {
-      moveStates.delete(win.id)
-      return
+      moveStates.delete(win.id);
+      return;
     }
-    moveStates.set(win.id, moveState)
-  })
+    moveStates.set(win.id, moveState);
+  });
 
-  ipcMain.on('paseo:window:moving', (event, payload: { screenX: number; screenY: number }) => {
-    const win = BrowserWindow.fromWebContents(event.sender)
-    if (!win) return
-    const state = moveStates.get(win.id)
-    if (!state) return
-    const movePayload = readWindowMovePayload(payload)
+  ipcMain.on("paseo:window:moving", (event, payload: { screenX: number; screenY: number }) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (!win) return;
+    const state = moveStates.get(win.id);
+    if (!state) return;
+    const movePayload = readWindowMovePayload(payload);
     if (!movePayload) {
-      moveStates.delete(win.id)
-      return
+      moveStates.delete(win.id);
+      return;
     }
     const nextPosition = resolveWindowMovePosition({
       payload: movePayload,
       state,
-    })
+    });
     if (!nextPosition) {
-      moveStates.delete(win.id)
-      return
+      moveStates.delete(win.id);
+      return;
     }
-    win.setPosition(nextPosition.x, nextPosition.y)
-  })
+    win.setPosition(nextPosition.x, nextPosition.y);
+  });
 
-  ipcMain.on('paseo:window:endMove', (event) => {
-    const win = BrowserWindow.fromWebContents(event.sender)
-    if (win) moveStates.delete(win.id)
-  })
+  ipcMain.on("paseo:window:endMove", (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) moveStates.delete(win.id);
+  });
 
-  app.on('browser-window-created', (_event, win) => {
-    win.on('closed', () => moveStates.delete(win.id))
-  })
+  app.on("browser-window-created", (_event, win) => {
+    win.on("closed", () => moveStates.delete(win.id));
+  });
 
-  ipcMain.handle('paseo:window:toggleMaximize', (event) => {
-    const win = BrowserWindow.fromWebContents(event.sender)
-    if (!win) return
+  ipcMain.handle("paseo:window:toggleMaximize", (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (!win) return;
     if (win.isMaximized()) {
-      win.unmaximize()
+      win.unmaximize();
     } else {
-      win.maximize()
+      win.maximize();
     }
-  })
+  });
 
-  ipcMain.handle('paseo:window:isFullscreen', (event) => {
-    const win = BrowserWindow.fromWebContents(event.sender)
-    return win?.isFullScreen() ?? false
-  })
+  ipcMain.handle("paseo:window:isFullscreen", (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    return win?.isFullScreen() ?? false;
+  });
 
-  ipcMain.handle('paseo:window:setBadgeCount', (_event, count?: number) => {
-    if (process.platform === 'darwin' || process.platform === 'linux') {
-      app.setBadgeCount(count ?? 0)
+  ipcMain.handle("paseo:window:setBadgeCount", (_event, count?: number) => {
+    if (process.platform === "darwin" || process.platform === "linux") {
+      app.setBadgeCount(count ?? 0);
     }
-  })
+  });
 }
 
 export function setupWindowResizeEvents(win: BrowserWindow): void {
-  win.on('resize', () => {
-    win.webContents.send('paseo:window:resized', {})
-  })
+  win.on("resize", () => {
+    win.webContents.send("paseo:window:resized", {});
+  });
 
-  win.on('enter-full-screen', () => {
-    win.webContents.send('paseo:window:resized', {})
-  })
+  win.on("enter-full-screen", () => {
+    win.webContents.send("paseo:window:resized", {});
+  });
 
-  win.on('leave-full-screen', () => {
-    win.webContents.send('paseo:window:resized', {})
-  })
+  win.on("leave-full-screen", () => {
+    win.webContents.send("paseo:window:resized", {});
+  });
 }
 
 /**
@@ -105,11 +105,11 @@ export function setupWindowResizeEvents(win: BrowserWindow): void {
  * The renderer handles drag-drop via standard HTML5 APIs instead.
  */
 export function setupDragDropPrevention(win: BrowserWindow): void {
-  win.webContents.on('will-navigate', (event, url) => {
+  win.webContents.on("will-navigate", (event, url) => {
     // Allow normal navigation (e.g. dev server hot-reload) but block file:// URLs
     // that result from dropping files onto the window.
-    if (url.startsWith('file://')) {
-      event.preventDefault()
+    if (url.startsWith("file://")) {
+      event.preventDefault();
     }
-  })
+  });
 }