feat: log viewer, downloads, settings and document viewer as separate windows on a shared native shell

rollup.config.mjs

@@ -288,6 +288,96 @@ export default [
       },
     ],
   },
+  {
+    external: makeExternal(['@bugsnag/js']),
+    input: 'src/downloadsWindow/downloads-window.tsx',
+    preserveEntrySignatures: 'strict',
+    plugins: [
+      json(),
+      replace({
+        'process.env.NODE_ENV': JSON.stringify(NODE_ENV),
+        'preventAssignment': true,
+      }),
+      babel({
+        babelHelpers: 'bundled',
+        extensions,
+      }),
+      nodeResolve({
+        browser: true,
+        extensions,
+      }),
+      commonjs(),
+      run(),
+    ],
+    output: [
+      {
+        dir: 'app',
+        format: 'cjs',
+        sourcemap: 'inline',
+        interop: 'auto',
+      },
+    ],
+  },
+  {
+    external: makeExternal(['@bugsnag/js']),
+    input: 'src/settingsWindow/settings-window.tsx',
+    preserveEntrySignatures: 'strict',
+    plugins: [
+      json(),
+      replace({
+        'process.env.NODE_ENV': JSON.stringify(NODE_ENV),
+        'preventAssignment': true,
+      }),
+      babel({
+        babelHelpers: 'bundled',
+        extensions,
+      }),
+      nodeResolve({
+        browser: true,
+        extensions,
+      }),
+      commonjs(),
+      run(),
+    ],
+    output: [
+      {
+        dir: 'app',
+        format: 'cjs',
+        sourcemap: 'inline',
+        interop: 'auto',
+      },
+    ],
+  },
+  {
+    external: makeExternal(['@bugsnag/js']),
+    input: 'src/documentViewerWindow/document-viewer-window.tsx',
+    preserveEntrySignatures: 'strict',
+    plugins: [
+      json(),
+      replace({
+        'process.env.NODE_ENV': JSON.stringify(NODE_ENV),
+        'preventAssignment': true,
+      }),
+      babel({
+        babelHelpers: 'bundled',
+        extensions,
+      }),
+      nodeResolve({
+        browser: true,
+        extensions,
+      }),
+      commonjs(),
+      run(),
+    ],
+    output: [
+      {
+        dir: 'app',
+        format: 'cjs',
+        sourcemap: 'inline',
+        interop: 'auto',
+      },
+    ],
+  },
   {
     external: makeExternal(['@bugsnag/js']),
     input: 'src/screenSharing/screen-picker-window.tsx',

src/app/PersistableValues.ts

@@ -120,6 +120,13 @@ type PersistableValues_4_15_0 = PersistableValues_4_14_0 & {
 
 type PersistableValues_4_16_0 = PersistableValues_4_15_0 & {
   navigationLayout: 'tabs' | 'sidebar' | 'hidden';
+  isLogViewerWindowOpen: boolean;
+  isDownloadsWindowOpen: boolean;
+  isSettingsWindowOpen: boolean;
+  secondaryWindowStates: Record<
+    string,
+    { x: number; y: number; width: number; height: number }
+  >;
 };
 
 type PersistableValues_4_16_1 = PersistableValues_4_16_0 & {
@@ -257,6 +264,17 @@ export const migrations = {
     ...before,
     navigationLayout:
       (before as Partial<PersistableValues_4_16_0>).navigationLayout ?? 'tabs',
+    isLogViewerWindowOpen:
+      (before as Partial<PersistableValues_4_16_0>).isLogViewerWindowOpen ??
+      false,
+    isDownloadsWindowOpen:
+      (before as Partial<PersistableValues_4_16_0>).isDownloadsWindowOpen ??
+      false,
+    isSettingsWindowOpen:
+      (before as Partial<PersistableValues_4_16_0>).isSettingsWindowOpen ??
+      false,
+    secondaryWindowStates:
+      (before as Partial<PersistableValues_4_16_0>).secondaryWindowStates ?? {},
   }),
   '>=4.16.1': (before: PersistableValues_4_16_0): PersistableValues_4_16_1 => ({
     ...before,

src/app/main/app.ts

@@ -315,6 +315,17 @@ export const setupGpuCrashHandler = (): void => {
 };
 
 export const setupApp = (): void => {
+  // The About menu item shows the system panel on macOS; without this it would
+  // report Electron's own name and version in an unpackaged run, since those
+  // otherwise come from the bundle's Info.plist.
+  if (process.platform === 'darwin') {
+    app.setAboutPanelOptions({
+      applicationName: packageJson.productName,
+      applicationVersion: app.getVersion(),
+      copyright: packageJson.copyright,
+    });
+  }
+
   app.addListener('activate', async () => {
     try {
       const browserWindow = await getRootWindow();

src/app/main/persistence.main.spec.ts

@@ -0,0 +1,122 @@
+import type { PersistableValues } from '../PersistableValues';
+import type * as PersistenceModule from './persistence';
+
+const mockSet = jest.fn();
+
+jest.mock('electron', () => ({
+  app: {
+    getVersion: jest.fn().mockReturnValue('1.0.0'),
+  },
+}));
+
+jest.mock('electron-store', () => {
+  return jest.fn().mockImplementation(() => ({
+    store: {},
+    set: mockSet,
+    get: jest.fn(),
+  }));
+});
+
+const value = (n: number): PersistableValues =>
+  ({ marker: n }) as unknown as PersistableValues;
+
+describe('persistValues throttling', () => {
+  let persistValues: typeof PersistenceModule.persistValues;
+  let flushPersistedValues: typeof PersistenceModule.flushPersistedValues;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(0);
+    mockSet.mockClear();
+    jest.resetModules();
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const persistence: typeof PersistenceModule = require('./persistence');
+    persistValues = persistence.persistValues;
+    flushPersistedValues = persistence.flushPersistedValues;
+  });
+
+  afterEach(() => {
+    flushPersistedValues();
+    jest.useRealTimers();
+  });
+
+  it('writes immediately when outside the throttle window', () => {
+    jest.advanceTimersByTime(2000);
+    persistValues(value(1));
+
+    expect(mockSet).toHaveBeenCalledTimes(1);
+    expect(mockSet).toHaveBeenCalledWith(value(1));
+  });
+
+  it('writes immediately when the throttle interval has elapsed exactly', () => {
+    jest.advanceTimersByTime(2000);
+    persistValues(value(1));
+    mockSet.mockClear();
+
+    jest.advanceTimersByTime(1000);
+    persistValues(value(2));
+
+    expect(mockSet).toHaveBeenCalledTimes(1);
+    expect(mockSet).toHaveBeenCalledWith(value(2));
+  });
+
+  it('coalesces rapid successive calls and persists only the final values after the trailing interval', () => {
+    jest.advanceTimersByTime(2000);
+    persistValues(value(1));
+    mockSet.mockClear();
+
+    jest.advanceTimersByTime(100);
+    persistValues(value(2));
+    jest.advanceTimersByTime(200);
+    persistValues(value(3));
+    jest.advanceTimersByTime(200);
+    persistValues(value(4));
+
+    expect(mockSet).not.toHaveBeenCalled();
+
+    jest.advanceTimersByTime(500);
+
+    expect(mockSet).toHaveBeenCalledTimes(1);
+    expect(mockSet).toHaveBeenCalledWith(value(4));
+  });
+
+  it('does not drop the final write when it lands inside the throttle window', () => {
+    jest.advanceTimersByTime(2000);
+    persistValues(value(1));
+    mockSet.mockClear();
+
+    jest.advanceTimersByTime(200);
+    persistValues(value(2));
+
+    jest.advanceTimersByTime(800);
+
+    expect(mockSet).toHaveBeenCalledTimes(1);
+    expect(mockSet).toHaveBeenCalledWith(value(2));
+  });
+
+  it('flush writes pending values immediately without waiting for the trailing timer', () => {
+    jest.advanceTimersByTime(2000);
+    persistValues(value(1));
+    mockSet.mockClear();
+
+    jest.advanceTimersByTime(200);
+    persistValues(value(2));
+
+    expect(mockSet).not.toHaveBeenCalled();
+
+    flushPersistedValues();
+
+    expect(mockSet).toHaveBeenCalledTimes(1);
+    expect(mockSet).toHaveBeenCalledWith(value(2));
+  });
+
+  it('flush is a no-op when there is no pending write', () => {
+    jest.advanceTimersByTime(2000);
+    persistValues(value(1));
+    mockSet.mockClear();
+
+    flushPersistedValues();
+
+    expect(mockSet).not.toHaveBeenCalled();
+  });
+});

src/app/main/persistence.ts

@@ -43,15 +43,59 @@ export const setPersistedMeta = (key: string, value: unknown): void => {
   }
 };
 
+const THROTTLE_INTERVAL_MS = 1000;
+
 let lastSavedTime = 0;
+let pendingValues: PersistableValues | null = null;
+let trailingTimeout: ReturnType<typeof setTimeout> | null = null;
 
-export const persistValues = (values: PersistableValues): void => {
-  if (Date.now() - lastSavedTime > 1000) {
-    try {
-      getElectronStore().set(values);
-    } catch (error) {
-      error instanceof Error && console.error(error);
+const writeNow = (values: PersistableValues): void => {
+  try {
+    getElectronStore().set(values);
+  } catch (error) {
+    error instanceof Error && console.error(error);
+  }
+  lastSavedTime = Date.now();
+};
+
+const scheduleTrailingSave = (delay: number): void => {
+  if (trailingTimeout) {
+    return;
+  }
+
+  trailingTimeout = setTimeout(() => {
+    trailingTimeout = null;
+    if (pendingValues) {
+      const values = pendingValues;
+      pendingValues = null;
+      writeNow(values);
     }
-    lastSavedTime = Date.now();
+  }, delay);
+};
+
+export const persistValues = (values: PersistableValues): void => {
+  const elapsed = Date.now() - lastSavedTime;
+
+  if (elapsed >= THROTTLE_INTERVAL_MS) {
+    pendingValues = null;
+    writeNow(values);
+    return;
+  }
+
+  pendingValues = values;
+  scheduleTrailingSave(THROTTLE_INTERVAL_MS - elapsed);
+};
+
+/** Synchronously flush any pending trailing write, e.g. before app quit. */
+export const flushPersistedValues = (): void => {
+  if (trailingTimeout) {
+    clearTimeout(trailingTimeout);
+    trailingTimeout = null;
+  }
+
+  if (pendingValues) {
+    const values = pendingValues;
+    pendingValues = null;
+    writeNow(values);
   }
 };

src/app/selectors.ts

@@ -99,6 +99,14 @@ const selectPersistableValuesB = createStructuredSelector({
     telephonyGlobalShortcutConfig,
   }: RootState) => telephonyGlobalShortcutConfig,
   isTelephonyEnabled: ({ isTelephonyEnabled }: RootState) => isTelephonyEnabled,
+  isLogViewerWindowOpen: ({ isLogViewerWindowOpen }: RootState) =>
+    isLogViewerWindowOpen,
+  isDownloadsWindowOpen: ({ isDownloadsWindowOpen }: RootState) =>
+    isDownloadsWindowOpen,
+  isSettingsWindowOpen: ({ isSettingsWindowOpen }: RootState) =>
+    isSettingsWindowOpen,
+  secondaryWindowStates: ({ secondaryWindowStates }: RootState) =>
+    secondaryWindowStates,
 });
 
 export const selectPersistableValues = createSelector(