feat: sync version download statuses between windows

src/interfaces.ts

@@ -216,3 +216,16 @@ export enum WindowSpecificSetting {
   gitHubPublishAsPublic = 'gitHubPublishAsPublic',
   version = 'version',
 }
+
+export interface AppStateBroadcastChannel extends BroadcastChannel {
+  postMessage(params: AppStateBroadcastMessage): void;
+}
+
+export type AppStateBroadcastMessage = {
+  type: AppStateBroadcastMessageType.syncVersions;
+  payload: RunnableVersion[];
+};
+
+export enum AppStateBroadcastMessageType {
+  syncVersions = 'syncVersions',
+}

src/renderer/state.ts

@@ -16,6 +16,9 @@ import {
 } from 'mobx';
 
 import {
+  AppStateBroadcastChannel,
+  AppStateBroadcastMessage,
+  AppStateBroadcastMessageType,
   BlockableAccelerator,
   ElectronReleaseChannel,
   GenericDialogOptions,
@@ -66,10 +69,8 @@ export class AppState {
     timeStyle: 'medium',
   });
 
-  private settingKeyTypeGuard(key: never): never {
-    throw new Error(
-      `Unhandled setting ${key}, please handle it in the \`AppState\`.`,
-    );
+  private genericTypeGuard(_: never, errorMessage: string): never {
+    throw new Error(errorMessage);
   }
 
   // -- Persisted settings ------------------
@@ -207,6 +208,22 @@ export class AppState {
     versions: this.baseVersions,
   });
 
+  // Used for communications between windows
+  private broadcastChannel: AppStateBroadcastChannel = new BroadcastChannel(
+    'AppState',
+  );
+
+  // Notifies other windows that this version has changed so they can update their state to reflect that.
+  private broadcastVersionStates(versions: RunnableVersion[]) {
+    this.broadcastChannel.postMessage({
+      type: AppStateBroadcastMessageType.syncVersions,
+
+      // the RunnableVersion proxies can't be cloned by structuredClone,
+      // so we have to create plain objects out of them
+      payload: versions.map((version) => ({ ...version })),
+    });
+  }
+
   constructor(versions: RunnableVersion[]) {
     makeObservable<AppState, 'setPageHash'>(this, {
       Bisector: observable,
@@ -421,7 +438,10 @@ export class AppState {
           }
 
           default: {
-            this.settingKeyTypeGuard(key);
+            this.genericTypeGuard(
+              key,
+              `Unhandled setting "${key}", please handle it in the \`AppState\`.`,
+            );
           }
         }
       } else if (
@@ -435,6 +455,31 @@ export class AppState {
       }
     });
 
+    /**
+     * Handles communications between windows.
+     */
+    this.broadcastChannel.addEventListener(
+      'message',
+      (event: MessageEvent<AppStateBroadcastMessage>) => {
+        const { type, payload } = event.data;
+
+        switch (type) {
+          case AppStateBroadcastMessageType.syncVersions: {
+            this.setVersionStates(payload);
+
+            break;
+          }
+
+          default: {
+            this.genericTypeGuard(
+              type,
+              `Unhandled BroadcastChannel message "${type}", please handle it in the \`AppState\`.`,
+            );
+          }
+        }
+      },
+    );
+
     // Setup auto-runs
     autorun(() => this.save(GlobalSetting.theme, this.theme));
     autorun(() =>
@@ -689,6 +734,15 @@ export class AppState {
     for (const ver of versions) {
       this.versions[ver.version] ||= ver;
     }
+
+    this.broadcastVersionStates(versions);
+  }
+
+  // Updates the version states in the current window to reflect updates made by other windows.
+  private setVersionStates(versions: RunnableVersion[]) {
+    for (const ver of versions) {
+      this.versions[ver.version] = ver;
+    }
   }
 
   /**
@@ -725,6 +779,8 @@ export class AppState {
           };
 
           await typeDefsCleaner();
+
+          this.broadcastVersionStates([ver]);
         }
       } else {
         console.log(`State: Version ${version} already removed, doing nothing`);
@@ -763,22 +819,33 @@ export class AppState {
 
     console.log(`State: Downloading Electron ${version}`);
 
+    this.broadcastVersionStates([
+      {
+        ...ver,
+        state: InstallState.downloading,
+      },
+    ]);
+
     // Download the version without setting it as the current version.
     await this.installer.ensureDownloaded(version, {
       mirror: {
         electronMirror,
         electronNightlyMirror,
       },
-      progressCallback(progress: ProgressObject) {
+      progressCallback: (progress: ProgressObject) => {
         // https://mobx.js.org/actions.html#runinaction
         runInAction(() => {
           const percent = Math.round(progress.percent * 100) / 100;
           if (ver.downloadProgress !== percent) {
             ver.downloadProgress = percent;
+
+            this.broadcastVersionStates([ver]);
           }
         });
       },
     });
+
+    this.broadcastVersionStates([ver]);
   }
 
   /**

tests/renderer/state-spec.ts

@@ -1,6 +1,7 @@
 import { reaction } from 'mobx';
 
 import {
+  AppStateBroadcastMessageType,
   BlockableAccelerator,
   ElectronReleaseChannel,
   GenericDialogType,
@@ -46,6 +47,7 @@ describe('AppState', () => {
   let removeSpy: jest.SpyInstance;
   let installSpy: jest.SpyInstance;
   let ensureDownloadedSpy: jest.SpyInstance;
+  let broadcastMessageSpy: jest.SpyInstance;
 
   beforeEach(() => {
     ({ mockVersions, mockVersionsArray } = new VersionsMock());
@@ -65,6 +67,10 @@ describe('AppState', () => {
     ensureDownloadedSpy = jest
       .spyOn(appState.installer, 'ensureDownloaded')
       .mockResolvedValue({ path: '', alreadyExtracted: false });
+    broadcastMessageSpy = jest.spyOn(
+      (appState as any).broadcastChannel,
+      'postMessage',
+    );
   });
 
   it('exists', () => {
@@ -96,6 +102,10 @@ describe('AppState', () => {
       const newCount = Object.keys(appState.versions).length;
       expect(newCount).toBe(oldCount + 1);
       expect(appState.versions[version]).toStrictEqual(ver);
+      expect(broadcastMessageSpy).toHaveBeenCalledWith({
+        type: AppStateBroadcastMessageType.syncVersions,
+        payload: [ver],
+      });
     });
   });
 
@@ -300,22 +310,30 @@ describe('AppState', () => {
 
     it('does not remove the active version', async () => {
       const ver = appState.versions[active];
+      broadcastMessageSpy.mockClear();
       await appState.removeVersion(ver);
       expect(removeSpy).not.toHaveBeenCalled();
+      expect(broadcastMessageSpy).not.toHaveBeenCalled();
     });
 
     it('removes a version', async () => {
       const ver = appState.versions[version];
       ver.state = InstallState.installed;
       await appState.removeVersion(ver);
       expect(removeSpy).toHaveBeenCalledWith<any>(ver.version);
+      expect(broadcastMessageSpy).toHaveBeenCalledWith({
+        type: AppStateBroadcastMessageType.syncVersions,
+        payload: [ver],
+      });
     });
 
     it('does not remove it if not necessary', async () => {
       const ver = appState.versions[version];
       ver.state = InstallState.missing;
+      broadcastMessageSpy.mockClear();
       await appState.removeVersion(ver);
       expect(removeSpy).toHaveBeenCalledTimes(0);
+      expect(broadcastMessageSpy).not.toHaveBeenCalled();
     });
 
     it('removes (but does not delete) a local version', async () => {
@@ -326,11 +344,13 @@ describe('AppState', () => {
       ver.source = VersionSource.local;
       ver.state = InstallState.installed;
 
+      broadcastMessageSpy.mockClear();
       await appState.removeVersion(ver);
 
       expect(saveLocalVersions).toHaveBeenCalledTimes(1);
       expect(appState.versions[version]).toBeUndefined();
       expect(removeSpy).toHaveBeenCalledTimes(0);
+      expect(broadcastMessageSpy).not.toHaveBeenCalled();
     });
   });
 
@@ -343,16 +363,22 @@ describe('AppState', () => {
 
       expect(ensureDownloadedSpy).toHaveBeenCalled();
       expect(installSpy).not.toHaveBeenCalled();
+      expect(broadcastMessageSpy).toHaveBeenCalledWith({
+        type: AppStateBroadcastMessageType.syncVersions,
+        payload: [ver],
+      });
     });
 
     it('does not download a version if already ready', async () => {
       const ver = appState.versions['2.0.2'];
       ver.state = InstallState.installed;
 
+      broadcastMessageSpy.mockClear();
       await appState.downloadVersion(ver);
 
       expect(ensureDownloadedSpy).not.toHaveBeenCalled();
       expect(installSpy).not.toHaveBeenCalled();
+      expect(broadcastMessageSpy).not.toHaveBeenCalled();
     });
   });
 
@@ -743,4 +769,24 @@ describe('AppState', () => {
       expect(actual).toBe(expected);
     });
   });
+
+  describe('broadcastChannel', () => {
+    it('updates the version state in response to changes in other windows', async () => {
+      const fakeVersion = {
+        version: '13.9.9',
+        state: InstallState.downloading,
+      } as RunnableVersion;
+
+      expect(appState.versions[fakeVersion.version]).toBeFalsy();
+
+      (appState as any).broadcastChannel.postMessage({
+        type: AppStateBroadcastMessageType.syncVersions,
+        payload: [fakeVersion],
+      });
+
+      expect(appState.versions[fakeVersion.version].state).toEqual(
+        InstallState.downloading,
+      );
+    });
+  });
 });

tests/setup.js

@@ -32,6 +32,31 @@ jest.mock('@sentry/electron/renderer', () => ({
   init: jest.fn(),
 }));
 
+class FakeBroadcastChannel extends EventTarget {
+  constructor(channelName) {
+    super();
+    this.name = channelName;
+  }
+
+  postMessage(message) {
+    this.dispatchEvent(new MessageEvent('message', { data: message }));
+  }
+}
+
+global.BroadcastChannel = class Singleton {
+  static channels = new Map();
+
+  constructor(channelName) {
+    if (!Singleton.channels.has(channelName)) {
+      Singleton.channels.set(
+        channelName,
+        new FakeBroadcastChannel(channelName),
+      );
+    }
+    return Singleton.channels.get(channelName);
+  }
+};
+
 expect.addSnapshotSerializer(createSerializer({ mode: 'deep' }));
 
 // We want to detect jest sometimes