feat(electron): remeber window position (fixes #121)

src/electron-window-state.ts

@@ -0,0 +1,65 @@
+import { BrowserWindow, BrowserWindowConstructorOptions } from 'electron';
+import { fromEvent } from 'rxjs/observable/fromEvent';
+import { merge } from 'rxjs/observable/merge';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+
+import { FileDataStore, IDataStore } from './server/datastore';
+
+interface IState {
+  fullscreen: boolean;
+  maximized: boolean;
+  options: Partial<BrowserWindowConstructorOptions>;
+}
+
+/**
+ * ElectronWindowState stores and restores window position information.
+ */
+export class ElectronWindowState {
+  /**
+   * Where window position preferences are stored in the IDataStore.
+   */
+  public static readonly storeKey = 'window-position';
+
+  constructor(private readonly store: IDataStore = new FileDataStore()) {}
+
+  /**
+   * Loads the stored window configuration.
+   */
+  public async restore(): Promise<Partial<BrowserWindowConstructorOptions>> {
+    return (await this.loadState()).options;
+  }
+
+  /**
+   * Watches for position changes in the window, saving preferences when
+   * the window is moved or closed.
+   */
+  public async watch(window: BrowserWindow) {
+    const state = await this.loadState();
+    if (state.maximized) {
+      window.maximize();
+    }
+    if (state.fullscreen) {
+      window.setFullScreen(true);
+    }
+
+    merge(fromEvent(window, 'resize'), fromEvent(window, 'move'))
+      .pipe(takeUntil(fromEvent(window, 'closed')), debounceTime(500))
+      .subscribe(async () => this.saveState(window));
+  }
+
+  private async saveState(window: BrowserWindow): Promise<void> {
+    await this.store.saveGlobal<IState>(ElectronWindowState.storeKey, {
+      fullscreen: window.isFullScreen(),
+      maximized: window.isMaximized(),
+      options: window.getBounds(),
+    });
+  }
+
+  private async loadState(): Promise<IState> {
+    return this.store.loadGlobal<IState>(ElectronWindowState.storeKey, {
+      fullscreen: false,
+      maximized: false,
+      options: {},
+    });
+  }
+}

src/electron.ts

@@ -4,24 +4,42 @@ import * as fixPath from 'fix-path';
 import * as path from 'path';
 import * as url from 'url';
 
+import { ElectronWindowState } from './electron-window-state';
 import { ElectronServer } from './server/electron-server';
 
 autoUpdater.checkForUpdatesAndNotify().catch(err => err);
 
-let window: BrowserWindow | null = null;
+let hasOpenWindow = false;
 let server: ElectronServer;
 
+const windowState = new ElectronWindowState();
 const isDebug = process.argv.includes('--debug');
+
 fixPath();
 
-function createWindow() {
-  window = new BrowserWindow({
-    width: 1280,
-    height: 720,
-    webPreferences: {
-      webSecurity: false,
-    },
-  });
+/**
+ * Creates a new BrowserWindow, seeding config from the stored state.
+ */
+async function createBrowserWindow() {
+  return windowState
+    .restore()
+    .catch(() => ({}))
+    .then(
+      windowOptions =>
+        new BrowserWindow({
+          width: 1280,
+          height: 720,
+          ...windowOptions,
+          webPreferences: {
+            webSecurity: false,
+          },
+        }),
+    );
+}
+
+function setupWindow(window: BrowserWindow) {
+  hasOpenWindow = true;
+  windowState.watch(window).catch(() => undefined);
 
   if (isDebug) {
     // tslint:disable-next-line
@@ -59,16 +77,26 @@ function createWindow() {
     );
   }
 
-  window.on('closed', () => (window = null));
+  window.on('closed', () => (hasOpenWindow = false));
   window.setMenu(null);
 
   server = new ElectronServer(window);
   server.start();
 }
 
-app.on('ready', createWindow);
+function boot() {
+  createBrowserWindow()
+    .then(setupWindow)
+    .catch(() => undefined);
+}
+
+app.on('ready', boot);
 
 app.on('window-all-closed', () => {
+  if (!server) {
+    return;
+  }
+
   server
     .stop()
     .catch(() => undefined)
@@ -79,7 +107,7 @@ app.on('window-all-closed', () => {
 });
 
 app.on('activate', () => {
-  if (window === null) {
-    createWindow();
+  if (!hasOpenWindow) {
+    boot();
   }
 });