fix: Set default server servers.json and Open server on click notification (#2144)

Author: ggazzo

src/notifications/main.ts

@@ -1,7 +1,8 @@
 import { Notification, nativeImage, NativeImage } from 'electron';
 
 import { invoke } from '../ipc/main';
-import { dispatch, listen } from '../store';
+import { dispatch, dispatchSingle, listen } from '../store';
+import { ActionIPCMeta } from '../store/actions';
 import { hasMeta } from '../store/fsa';
 import { getRootWindow } from '../ui/main/rootWindow';
 import {
@@ -45,7 +46,8 @@ const notifications = new Map();
 
 const createNotification = async (
   id: string,
-  { title, body, icon, silent, canReply, actions }: ExtendedNotificationOptions
+  { title, body, icon, silent, canReply, actions }: ExtendedNotificationOptions,
+  ipcMeta?: ActionIPCMeta
 ): Promise<string> => {
   const notification = new Notification({
     title,
@@ -60,29 +62,43 @@ const createNotification = async (
   });
 
   notification.addListener('show', () => {
-    dispatch({ type: NOTIFICATIONS_NOTIFICATION_SHOWN, payload: { id } });
+    dispatchSingle({
+      type: NOTIFICATIONS_NOTIFICATION_SHOWN,
+      payload: { id },
+      ipcMeta,
+    });
   });
 
   notification.addListener('close', () => {
-    dispatch({ type: NOTIFICATIONS_NOTIFICATION_CLOSED, payload: { id } });
+    dispatchSingle({
+      type: NOTIFICATIONS_NOTIFICATION_CLOSED,
+      payload: { id },
+      ipcMeta,
+    });
     notifications.delete(id);
   });
 
   notification.addListener('click', () => {
-    dispatch({ type: NOTIFICATIONS_NOTIFICATION_CLICKED, payload: { id } });
+    dispatchSingle({
+      type: NOTIFICATIONS_NOTIFICATION_CLICKED,
+      payload: { id },
+      ipcMeta,
+    });
   });
 
   notification.addListener('reply', (_event, reply) => {
-    dispatch({
+    dispatchSingle({
       type: NOTIFICATIONS_NOTIFICATION_REPLIED,
       payload: { id, reply },
+      ipcMeta,
     });
   });
 
   notification.addListener('action', (_event, index) => {
-    dispatch({
+    dispatchSingle({
       type: NOTIFICATIONS_NOTIFICATION_ACTIONED,
       payload: { id, index },
+      ipcMeta,
     });
   });
 
@@ -118,27 +134,26 @@ const updateNotification = async (
   return id;
 };
 
-const handleCreateEvent = async ({
-  tag,
-  ...options
-}: ExtendedNotificationOptions): Promise<string> => {
+const handleCreateEvent = async (
+  { tag, ...options }: ExtendedNotificationOptions,
+  ipcMeta?: ActionIPCMeta
+): Promise<string> => {
   if (tag && notifications.has(tag)) {
     return updateNotification(tag, options);
   }
 
   const id = tag || Math.random().toString(36).slice(2);
-  return createNotification(id, options);
+  return createNotification(id, options, ipcMeta);
 };
 
 export const setupNotifications = (): void => {
   listen(NOTIFICATIONS_CREATE_REQUESTED, async (action) => {
     if (!hasMeta(action)) {
       return;
     }
-
     dispatch({
       type: NOTIFICATIONS_CREATE_RESPONDED,
-      payload: await handleCreateEvent(action.payload),
+      payload: await handleCreateEvent(action.payload, action.ipcMeta),
       meta: {
         id: action.meta.id,
         response: true,

src/store/actions.ts

@@ -37,4 +37,11 @@ type RootActions = {
 
 export type ActionOf<Type extends keyof RootActions> = RootActions[Type];
 
-export type RootAction = RootActions[keyof RootActions];
+export type RootAction = RootActions[keyof RootActions] & {
+  ipcMeta?: ActionIPCMeta;
+};
+
+export type ActionIPCMeta = {
+  type: 'single' | 'local';
+  webContentsId?: number;
+};

src/store/fsa.ts

@@ -41,6 +41,15 @@ export const isLocallyScoped = <
   hasMeta(action) &&
   (action as Action & { meta: { scope: unknown } }).meta.scope === 'local';
 
+export const isSingleScoped = <
+  Action extends FluxStandardAction<string, unknown>
+>(
+  action: Action
+): action is Action & { ipcMeta: { scope: 'single'; webContentsId: number } } =>
+  (action as any & { ipcMeta: { webContentsId: unknown } }).ipcMeta
+    ?.webContentsId &&
+  (action as any & { ipcMeta: { scope: unknown } }).ipcMeta?.scope === 'single';
+
 export const isErrored = <Action extends FluxStandardAction<string, unknown>>(
   action: Action
 ): action is Action & { error: true; payload: Error } =>

src/store/index.ts

@@ -45,6 +45,25 @@ export const dispatch = <Action extends RootAction>(action: Action): void => {
   reduxStore.dispatch(action);
 };
 
+export const dispatchSingle = <Action extends RootAction>(
+  action: Action
+): void => {
+  reduxStore.dispatch({
+    ...action,
+    ipcMeta: { ...action.ipcMeta, scope: 'single' },
+  });
+};
+
+export const dispatchLocal = <Action extends RootAction>(
+  action: Action
+): void => {
+  reduxStore.dispatch({
+    ...action,
+    ipcMeta: { ...action.ipcMeta, scope: 'local' },
+    meta: { scope: 'local' },
+  });
+};
+
 type Selector<T> = (state: RootState) => T;
 
 export const select = <T>(selector: Selector<T>): T =>

src/store/ipc.ts

@@ -6,42 +6,58 @@ import {
   handle as handleFromRenderer,
   invoke as invokeFromRenderer,
 } from '../ipc/renderer';
-import { isFSA, FluxStandardAction, isLocallyScoped, hasMeta } from './fsa';
+import {
+  isFSA,
+  FluxStandardAction,
+  isLocallyScoped,
+  hasMeta,
+  isSingleScoped,
+} from './fsa';
 
 const enum ActionScope {
   LOCAL = 'local',
+  SINGLE = 'single',
 }
 
 export const forwardToRenderers: Middleware = (api: MiddlewareAPI) => {
   const renderers = new Set<WebContents>();
 
   handleOnMain('redux/get-initial-state', async (webContents) => {
     renderers.add(webContents);
-
     webContents.addListener('destroyed', () => {
       renderers.delete(webContents);
     });
 
     return api.getState();
   });
 
-  handleOnMain('redux/action-dispatched', async (_, action) => {
-    api.dispatch(action);
+  handleOnMain('redux/action-dispatched', async (webContents, action) => {
+    api.dispatch({
+      ...action,
+      ipcMeta: { webContentsId: webContents.id, ...action.ipcMeta },
+    });
   });
 
   return (next: Dispatch) => (action: FluxStandardAction<string, unknown>) => {
     if (!isFSA(action) || isLocallyScoped(action)) {
       return next(action);
     }
-
     const rendererAction = {
       ...action,
       meta: {
         ...(hasMeta(action) && action.meta),
         scope: ActionScope.LOCAL,
       },
     };
-
+    if (isSingleScoped(action)) {
+      const { webContentsId } = action.ipcMeta;
+      [...renderers]
+        .filter((w) => w.id === webContentsId)
+        .forEach((w) => {
+          invokeFromMain(w, 'redux/action-dispatched', rendererAction);
+        });
+      return next(action);
+    }
     renderers.forEach((webContents) => {
       invokeFromMain(webContents, 'redux/action-dispatched', rendererAction);
     });

src/ui/main/debounce.ts

@@ -0,0 +1,11 @@
+export function debounce<T extends (...params: any[]) => unknown>(
+  cb: T,
+  wait = 20
+): T {
+  let h: ReturnType<typeof setTimeout> | undefined;
+  const callable = (...args: any) => {
+    h && clearTimeout(h);
+    h = setTimeout(() => cb(...args), wait);
+  };
+  return <T>(<any>callable);
+}

src/ui/main/rootWindow.ts

@@ -14,11 +14,12 @@ import { createStructuredSelector } from 'reselect';
 
 import { setupRootWindowReload } from '../../app/main/dev';
 import { Server } from '../../servers/common';
-import { dispatch, select, watch, listen } from '../../store';
+import { select, watch, listen, dispatchLocal } from '../../store';
 import { RootState } from '../../store/rootReducer';
 import { ROOT_WINDOW_STATE_CHANGED, WEBVIEW_FOCUS_REQUESTED } from '../actions';
 import { RootWindowIcon, WindowState } from '../common';
 import { selectGlobalBadge, selectGlobalBadgeCount } from '../selectors';
+import { debounce } from './debounce';
 import { getTrayIconPath } from './icons';
 
 const webPreferences: WebPreferences = {
@@ -207,12 +208,12 @@ export const setupRootWindow = (): void => {
     }),
   ];
 
-  const fetchAndDispatchWindowState = async (): Promise<void> => {
-    dispatch({
+  const fetchAndDispatchWindowState = debounce(async (): Promise<void> => {
+    dispatchLocal({
       type: ROOT_WINDOW_STATE_CHANGED,
       payload: await fetchRootWindowState(),
     });
-  };
+  }, 1000);
 
   getRootWindow().then((rootWindow) => {
     rootWindow.addListener('show', fetchAndDispatchWindowState);