release: New release v5.2.0.

Signed-off-by: Anders Kaseorg <anders@zulip.com>

.gitattributes

@@ -1,7 +1,5 @@
 * text=auto eol=lf
 
-package-lock.json binary
-app/package-lock.json binary
 *.gif binary
 *.jpg binary
 *.jpeg binary

.gitignore

@@ -1,5 +1,5 @@
-# Dependency directories
-node_modules/
+# Dependency directory
+/node_modules/
 
 # npm cache directory
 .npm

.travis.yml

@@ -1,6 +1,3 @@
-sudo: required
-dist: trusty
-
 os:
 - osx
 - linux
@@ -15,23 +12,12 @@ addons:
 
 language: node_js
 node_js:
-- '8'
-
-before_install:
-  - ./scripts/travis-xvfb.sh
-  - npm install -g gulp
-  - npm install
+- '10'
+- '12'
 
 cache:
   directories:
   - node_modules
-  - app/node_modules
 
 script:
-- npm run travis
-notifications:
-  webhooks:
-    urls:
-      - https://zulip.org/zulipbot/travis
-    on_success: always
-    on_failure: always
+- npm run test

app/main/autoupdater.ts

@@ -1,11 +1,11 @@
-'use strict';
-import { app, dialog, shell } from 'electron';
-import { autoUpdater } from 'electron-updater';
-import { linuxUpdateNotification } from './linuxupdater';	// Required only in case of linux
+import {app, dialog} from 'electron';
+import {UpdateDownloadedEvent, UpdateInfo, autoUpdater} from 'electron-updater';
+import {linuxUpdateNotification} from './linuxupdater';	// Required only in case of linux
 
-import log = require('electron-log');
-import isDev = require('electron-is-dev');
-import ConfigUtil = require('../renderer/js/utils/config-util');
+import log from 'electron-log';
+import isDev from 'electron-is-dev';
+import * as ConfigUtil from '../renderer/js/utils/config-util';
+import * as LinkUtil from '../renderer/js/utils/link-util';
 
 export function appUpdater(updateFromMenu = false): void {
 	// Don't initiate auto-updates in development
@@ -34,73 +34,73 @@ export function appUpdater(updateFromMenu = false): void {
 	autoUpdater.allowPrerelease = isBetaUpdate || false;
 
 	const eventsListenerRemove = ['update-available', 'update-not-available'];
-	autoUpdater.on('update-available', info => {
+	autoUpdater.on('update-available', async (info: UpdateInfo) => {
 		if (updateFromMenu) {
-			dialog.showMessageBox({
-				message: `A new version ${info.version}, of Zulip Desktop is available`,
-				detail: 'The update will be downloaded in the background. You will be notified when it is ready to be installed.'
-			});
-
 			updateAvailable = true;
 
 			// This is to prevent removal of 'update-downloaded' and 'error' event listener.
 			eventsListenerRemove.forEach(event => {
 				autoUpdater.removeAllListeners(event);
 			});
+
+			await dialog.showMessageBox({
+				message: `A new version ${info.version}, of Zulip Desktop is available`,
+				detail: 'The update will be downloaded in the background. You will be notified when it is ready to be installed.'
+			});
 		}
 	});
 
-	autoUpdater.on('update-not-available', () => {
+	autoUpdater.on('update-not-available', async () => {
 		if (updateFromMenu) {
-			dialog.showMessageBox({
+			// Remove all autoUpdator listeners so that next time autoUpdator is manually called these
+			// listeners don't trigger multiple times.
+			autoUpdater.removeAllListeners();
+
+			await dialog.showMessageBox({
 				message: 'No updates available',
 				detail: `You are running the latest version of Zulip Desktop.\nVersion: ${app.getVersion()}`
 			});
-			// Remove all autoUpdator listeners so that next time autoUpdator is manually called these
-			// listeners don't trigger multiple times.
-			autoUpdater.removeAllListeners();
 		}
 	});
 
-	autoUpdater.on('error', error => {
+	autoUpdater.on('error', async (error: Error) => {
 		if (updateFromMenu) {
-			const messageText = (updateAvailable) ? ('Unable to download the updates') : ('Unable to check for updates');
-			dialog.showMessageBox({
-				type: 'error',
-				buttons: ['Manual Download', 'Cancel'],
-				message: messageText,
-				detail: (error).toString() + `\n\nThe latest version of Zulip Desktop is available at -\nhttps://zulipchat.com/apps/.\n
-Current Version: ${app.getVersion()}`
-			}, response => {
-				if (response === 0) {
-					shell.openExternal('https://zulipchat.com/apps/');
-				}
-			});
 			// Remove all autoUpdator listeners so that next time autoUpdator is manually called these
 			// listeners don't trigger multiple times.
 			autoUpdater.removeAllListeners();
+
+			const messageText = (updateAvailable) ? ('Unable to download the updates') : ('Unable to check for updates');
+			const {response} = await dialog.showMessageBox({
+				type: 'error',
+				buttons: ['Manual Download', 'Cancel'],
+				message: messageText,
+				detail: `Error: ${error.message}\n\nThe latest version of Zulip Desktop is available at -\nhttps://zulipchat.com/apps/.\n
+				Current Version: ${app.getVersion()}`
+			});
+			if (response === 0) {
+				await LinkUtil.openBrowser(new URL('https://zulipchat.com/apps/'));
+			}
 		}
 	});
 
 	// Ask the user if update is available
-	autoUpdater.on('update-downloaded', event => {
+	autoUpdater.on('update-downloaded', async (event: UpdateDownloadedEvent) => {
 		// Ask user to update the app
-		dialog.showMessageBox({
+		const {response} = await dialog.showMessageBox({
 			type: 'question',
 			buttons: ['Install and Relaunch', 'Install Later'],
 			defaultId: 0,
 			message: `A new update ${event.version} has been downloaded`,
 			detail: 'It will be installed the next time you restart the application'
-		}, response => {
-			if (response === 0) {
-				setTimeout(() => {
-					autoUpdater.quitAndInstall();
-					// force app to quit. This is just a workaround, ideally autoUpdater.quitAndInstall() should relaunch the app.
-					app.quit();
-				}, 1000);
-			}
 		});
+		if (response === 0) {
+			setTimeout(() => {
+				autoUpdater.quitAndInstall();
+				// Force app to quit. This is just a workaround, ideally autoUpdater.quitAndInstall() should relaunch the app.
+				app.quit();
+			}, 1000);
+		}
 	});
 	// Init for updates
-	autoUpdater.checkForUpdates();
+	(async () => autoUpdater.checkForUpdates())();
 }

app/main/index.ts

@@ -1,19 +1,17 @@
-'use strict';
-import { sentryInit } from '../renderer/js/utils/sentry-util';
-import { appUpdater } from './autoupdater';
-import { setAutoLaunch } from './startup';
+import {sentryInit} from '../renderer/js/utils/sentry-util';
+import {appUpdater} from './autoupdater';
+import {setAutoLaunch} from './startup';
 
-import windowStateKeeper = require('electron-window-state');
-import path = require('path');
-import fs = require('fs');
-import isDev = require('electron-is-dev');
-import electron = require('electron');
-const { app, ipcMain, session } = electron;
+import windowStateKeeper from 'electron-window-state';
+import path from 'path';
+import fs from 'fs';
+import electron, {app, dialog, ipcMain, session} from 'electron';
 
-import AppMenu = require('./menu');
-import BadgeSettings = require('../renderer/js/pages/preference/badge-settings');
-import ConfigUtil = require('../renderer/js/utils/config-util');
-import ProxyUtil = require('../renderer/js/utils/proxy-util');
+import * as AppMenu from './menu';
+import * as BadgeSettings from '../renderer/js/pages/preference/badge-settings';
+import * as CertificateUtil from '../renderer/js/utils/certificate-util';
+import * as ConfigUtil from '../renderer/js/utils/config-util';
+import * as ProxyUtil from '../renderer/js/utils/proxy-util';
 
 interface PatchedGlobal extends NodeJS.Global {
 	mainWindowState: windowStateKeeper.State;
@@ -21,12 +19,6 @@ interface PatchedGlobal extends NodeJS.Global {
 
 const globalPatched = global as PatchedGlobal;
 
-// Adds debug features like hotkeys for triggering dev tools and reload
-// in development mode
-if (isDev) {
-	require('electron-debug')();
-}
-
 // Prevent window being garbage collected
 let mainWindow: Electron.BrowserWindow;
 let badgeCount: number;
@@ -51,12 +43,34 @@ if (singleInstanceLock) {
 	app.quit();
 }
 
+const rendererCallbacks = new Map();
+let nextRendererCallbackId = 0;
+
+ipcMain.on('renderer-callback', (event: Event, rendererCallbackId: number, ...args: any[]) => {
+	rendererCallbacks.get(rendererCallbackId)(...args);
+	rendererCallbacks.delete(rendererCallbackId);
+});
+
+function makeRendererCallback(callback: (...args: any[]) => void): number {
+	rendererCallbacks.set(nextRendererCallbackId, callback);
+	return nextRendererCallbackId++;
+}
+
 const APP_ICON = path.join(__dirname, '../resources', 'Icon');
 
 const iconPath = (): string => {
 	return APP_ICON + (process.platform === 'win32' ? '.ico' : '.png');
 };
 
+// Toggle the app window
+const toggleApp = (): void => {
+	if (!mainWindow.isVisible() || mainWindow.isMinimized()) {
+		mainWindow.show();
+	} else {
+		mainWindow.hide();
+	}
+};
+
 function createMainWindow(): Electron.BrowserWindow {
 	// Load the previous state with fallback to defaults
 	const mainWindowState: windowStateKeeper.State = windowStateKeeper({
@@ -81,7 +95,8 @@ function createMainWindow(): Electron.BrowserWindow {
 		webPreferences: {
 			plugins: true,
 			nodeIntegration: true,
-			partition: 'persist:webviewsession'
+			partition: 'persist:webviewsession',
+			webviewTag: true
 		},
 		show: false
 	});
@@ -90,15 +105,16 @@ function createMainWindow(): Electron.BrowserWindow {
 		win.webContents.send('focus');
 	});
 
-	win.loadURL(mainURL);
+	(async () => win.loadURL(mainURL))();
 
 	// Keep the app running in background on close event
-	win.on('close', e => {
-		if (ConfigUtil.getConfigItem("quitOnClose")) {
+	win.on('close', event => {
+		if (ConfigUtil.getConfigItem('quitOnClose')) {
 			app.quit();
 		}
+
 		if (!isQuitting) {
-			e.preventDefault();
+			event.preventDefault();
 
 			if (process.platform === 'darwin') {
 				app.hide();
@@ -119,8 +135,8 @@ function createMainWindow(): Electron.BrowserWindow {
 	});
 
 	//  To destroy tray icon when navigate to a new URL
-	win.webContents.on('will-navigate', e => {
-		if (e) {
+	win.webContents.on('will-navigate', event => {
+		if (event) {
 			win.webContents.send('destroytray');
 		}
 	});
@@ -140,19 +156,20 @@ app.disableHardwareAcceleration();
 // More info here - https://github.com/electron/electron/issues/10732
 app.commandLine.appendSwitch('force-color-profile', 'srgb');
 
-// eslint-disable-next-line max-params
-app.on('certificate-error', (event: Event, _webContents: Electron.WebContents, _url: string, _error: string, _certificate: any, callback) => {
-	event.preventDefault();
-	callback(true);
-});
-
+// This event is only available on macOS. Triggers when you click on the dock icon.
 app.on('activate', () => {
-	if (!mainWindow) {
+	if (mainWindow) {
+		// If there is already a window show it
+		mainWindow.show();
+	} else {
 		mainWindow = createMainWindow();
 	}
 });
 
 app.on('ready', () => {
+	const ses = session.fromPartition('persist:webviewsession');
+	ses.setUserAgent(`ZulipElectron/${app.getVersion()} ${ses.getUserAgent()}`);
+
 	AppMenu.setMenu({
 		tabs: []
 	});
@@ -161,7 +178,7 @@ app.on('ready', () => {
 	// Auto-hide menu bar on Windows + Linux
 	if (process.platform !== 'darwin') {
 		const shouldHideMenu = ConfigUtil.getConfigItem('autoHideMenubar') || false;
-		mainWindow.setAutoHideMenuBar(shouldHideMenu);
+		mainWindow.autoHideMenuBar = shouldHideMenu;
 		mainWindow.setMenuBarVisibility(!shouldHideMenu);
 	}
 
@@ -174,7 +191,7 @@ app.on('ready', () => {
 	const isSystemProxy = ConfigUtil.getConfigItem('useSystemProxy');
 
 	if (isSystemProxy) {
-		ProxyUtil.resolveSystemProxy(mainWindow);
+		(async () => ProxyUtil.resolveSystemProxy(mainWindow))();
 	}
 
 	const page = mainWindow.webContents;
@@ -185,10 +202,10 @@ app.on('ready', () => {
 		} else {
 			mainWindow.show();
 		}
-		if (!ConfigUtil.isConfigItemExists('userAgent')) {
-			const userAgent = session.fromPartition('webview:persistsession').getUserAgent();
-			ConfigUtil.setConfigItem('userAgent', userAgent);
-		}
+	});
+
+	ipcMain.on('fetch-user-agent', event => {
+		event.returnValue = session.fromPartition('persist:webviewsession').getUserAgent();
 	});
 
 	page.once('did-frame-finish-load', () => {
@@ -198,6 +215,64 @@ app.on('ready', () => {
 		}
 	});
 
+	app.on('certificate-error', (
+		event: Event,
+		webContents: Electron.WebContents,
+		url: string,
+		error: string,
+		certificate: Electron.Certificate,
+		callback: (isTrusted: boolean) => void
+	) /* eslint-disable-line max-params */ => {
+		// TODO: The entire concept of selectively ignoring certificate errors
+		// is ill-conceived, and this handler needs to be deleted.
+		event.preventDefault();
+
+		const {origin} = new URL(url);
+		const filename = CertificateUtil.getCertificate(encodeURIComponent(origin));
+		if (filename !== undefined) {
+			try {
+				const savedCertificate = fs.readFileSync(
+					path.join(`${app.getPath('userData')}/certificates`, filename),
+					'utf8'
+				);
+				if (certificate.data.replace(/[\r\n]/g, '') ===
+					savedCertificate.replace(/[\r\n]/g, '')) {
+					callback(true);
+					return;
+				}
+			} catch (error) {
+				console.error(`Error reading certificate file ${filename}:`, error);
+			}
+		}
+
+		page.send(
+			'certificate-error',
+			webContents.id === mainWindow.webContents.id ? null : webContents.id,
+			makeRendererCallback(ignore => {
+				callback(ignore);
+				if (!ignore) {
+					dialog.showErrorBox(
+						'Certificate error',
+						`The server presented an invalid certificate for ${origin}:
+
+${error}`
+					);
+				}
+			})
+		);
+	});
+
+	page.session.setPermissionRequestHandler((webContents, permission, callback, details) => {
+		const {origin} = new URL(details.requestingUrl);
+		page.send('permission-request', {
+			webContentsId: webContents.id === mainWindow.webContents.id ?
+				null :
+				webContents.id,
+			origin,
+			permission
+		}, makeRendererCallback(callback));
+	});
+
 	// Temporarily remove this event
 	// electron.powerMonitor.on('resume', () => {
 	// 	mainWindow.reload();
@@ -251,38 +326,34 @@ app.on('ready', () => {
 	});
 
 	ipcMain.on('toggle-app', () => {
-		if (!mainWindow.isVisible() || mainWindow.isMinimized()) {
-			mainWindow.show();
-		} else {
-			mainWindow.hide();
-		}
+		toggleApp();
 	});
 
 	ipcMain.on('toggle-badge-option', () => {
 		BadgeSettings.updateBadge(badgeCount, mainWindow);
 	});
 
-	ipcMain.on('toggle-menubar', (_event: Electron.IpcMessageEvent, showMenubar: boolean) => {
-		mainWindow.setAutoHideMenuBar(showMenubar);
+	ipcMain.on('toggle-menubar', (_event: Electron.IpcMainEvent, showMenubar: boolean) => {
+		mainWindow.autoHideMenuBar = showMenubar;
 		mainWindow.setMenuBarVisibility(!showMenubar);
 		page.send('toggle-autohide-menubar', showMenubar, true);
 	});
 
-	ipcMain.on('update-badge', (_event: Electron.IpcMessageEvent, messageCount: number) => {
+	ipcMain.on('update-badge', (_event: Electron.IpcMainEvent, messageCount: number) => {
 		badgeCount = messageCount;
 		BadgeSettings.updateBadge(badgeCount, mainWindow);
 		page.send('tray', messageCount);
 	});
 
-	ipcMain.on('update-taskbar-icon', (_event: Electron.IpcMessageEvent, data: any, text: string) => {
+	ipcMain.on('update-taskbar-icon', (_event: Electron.IpcMainEvent, data: string, text: string) => {
 		BadgeSettings.updateTaskbarIcon(data, text, mainWindow);
 	});
 
-	ipcMain.on('forward-message', (_event: Electron.IpcMessageEvent, listener: any, ...params: any[]) => {
-		page.send(listener, ...params);
+	ipcMain.on('forward-message', (_event: Electron.IpcMainEvent, listener: string, ...parameters: unknown[]) => {
+		page.send(listener, ...parameters);
 	});
 
-	ipcMain.on('update-menu', (_event: Electron.IpcMessageEvent, props: any) => {
+	ipcMain.on('update-menu', (_event: Electron.IpcMainEvent, props: AppMenu.MenuProps) => {
 		AppMenu.setMenu(props);
 		const activeTab = props.tabs[props.activeTabIndex];
 		if (activeTab) {
@@ -290,35 +361,39 @@ app.on('ready', () => {
 		}
 	});
 
-	ipcMain.on('toggleAutoLauncher', (_event: Electron.IpcMessageEvent, AutoLaunchValue: boolean) => {
-		setAutoLaunch(AutoLaunchValue);
+	ipcMain.on('toggleAutoLauncher', async (_event: Electron.IpcMainEvent, AutoLaunchValue: boolean) => {
+		await setAutoLaunch(AutoLaunchValue);
 	});
 
-	ipcMain.on('downloadFile', (_event: Electron.IpcMessageEvent, url: string, downloadPath: string) => {
+	ipcMain.on('downloadFile', (_event: Electron.IpcMainEvent, url: string, downloadPath: string) => {
 		page.downloadURL(url);
-		page.session.once('will-download', (_event: Event, item) => {
-			const filePath = path.join(downloadPath, item.getFilename());
+		page.session.once('will-download', async (_event: Event, item) => {
+			if (ConfigUtil.getConfigItem('promptDownload', false)) {
+				const showDialogOptions: object = {
+					defaultPath: path.join(downloadPath, item.getFilename())
+				};
+				item.setSaveDialogOptions(showDialogOptions);
+			} else {
+				const getTimeStamp = (): number => {
+					const date = new Date();
+					return date.getTime();
+				};
 
-			const getTimeStamp = (): any => {
-				const date = new Date();
-				return date.getTime();
-			};
+				const formatFile = (filePath: string): string => {
+					const fileExtension = path.extname(filePath);
+					const baseName = path.basename(filePath, fileExtension);
+					return `${baseName}-${getTimeStamp()}${fileExtension}`;
+				};
 
-			const formatFile = (filePath: string): string => {
-				const fileExtension = path.extname(filePath);
-				const baseName = path.basename(filePath, fileExtension);
-				return `${baseName}-${getTimeStamp()}${fileExtension}`;
-			};
+				const filePath = path.join(downloadPath, item.getFilename());
 
-			// Update the name and path of the file if it already exists
+				// Update the name and path of the file if it already exists
+				const updatedFilePath = path.join(downloadPath, formatFile(filePath));
+				const setFilePath: string = fs.existsSync(filePath) ? updatedFilePath : filePath;
+				item.setSavePath(setFilePath);
+			}
 
-			const updatedFilePath = path.join(downloadPath, formatFile(filePath));
-
-			const setFilePath = fs.existsSync(filePath) ? updatedFilePath : filePath;
-
-			item.setSavePath(setFilePath);
-
-			item.on('updated', (_event: Event, state) => {
+			const updatedListener = (_event: Event, state: string): void => {
 				switch (state) {
 					case 'interrupted': {
 						// Can interrupted to due to network error, cancel download then
@@ -326,47 +401,52 @@ app.on('ready', () => {
 						item.cancel();
 						break;
 					}
+
 					case 'progressing': {
 						if (item.isPaused()) {
 							item.cancel();
 						}
+
 						// This event can also be used to show progress in percentage in future.
 						break;
 					}
+
 					default: {
 						console.info('Unknown updated state of download item');
 					}
 				}
-			});
+			};
+
+			item.on('updated', updatedListener);
 			item.once('done', (_event: Event, state) => {
-				const getFileName = fs.existsSync(filePath) ? formatFile(filePath) : item.getFilename();
 				if (state === 'completed') {
-					page.send('downloadFileCompleted', item.getSavePath(), getFileName);
+					page.send('downloadFileCompleted', item.getSavePath(), path.basename(item.getSavePath()));
 				} else {
-					console.log('Download failed state: ', state);
-					page.send('downloadFileFailed');
+					console.log('Download failed state:', state);
+					page.send('downloadFileFailed', state);
 				}
+
 				// To stop item for listening to updated events of this file
-				item.removeAllListeners('updated');
+				item.removeListener('updated', updatedListener);
 			});
 		});
 	});
 
-	ipcMain.on('realm-name-changed', (_event: Electron.IpcMessageEvent, serverURL: string, realmName: string) => {
+	ipcMain.on('realm-name-changed', (_event: Electron.IpcMainEvent, serverURL: string, realmName: string) => {
 		page.send('update-realm-name', serverURL, realmName);
 	});
 
-	ipcMain.on('realm-icon-changed', (_event: Electron.IpcMessageEvent, serverURL: string, iconURL: string) => {
+	ipcMain.on('realm-icon-changed', (_event: Electron.IpcMainEvent, serverURL: string, iconURL: string) => {
 		page.send('update-realm-icon', serverURL, iconURL);
 	});
 
 	// Using event.sender.send instead of page.send here to
 	// make sure the value of errorReporting is sent only once on load.
-	ipcMain.on('error-reporting', (event: Electron.IpcMessageEvent) => {
+	ipcMain.on('error-reporting', (event: Electron.IpcMainEvent) => {
 		event.sender.send('error-reporting-val', errorReporting);
 	});
 
-	ipcMain.on('save-last-tab', (_event: Electron.IpcMessageEvent, index: number) => {
+	ipcMain.on('save-last-tab', (_event: Electron.IpcMainEvent, index: number) => {
 		ConfigUtil.setConfigItem('lastActiveTab', index);
 	});
 
@@ -375,19 +455,12 @@ app.on('ready', () => {
 	setInterval(() => {
 		// Set user idle if no activity in 1 second (idleThresholdSeconds)
 		const idleThresholdSeconds = 1; // 1 second
-
-		// TODO: Remove typecast to any when types get added
-		// TODO: use powerMonitor.getSystemIdleState when upgrading electron
-		// powerMonitor.querySystemIdleState is deprecated in current electron
-		// version at the time of writing.
-		const powerMonitor = electron.powerMonitor as any;
-		powerMonitor.querySystemIdleState(idleThresholdSeconds, (idleState: string) => {
-			if (idleState === 'active') {
-				page.send('set-active');
-			} else {
-				page.send('set-idle');
-			}
-		});
+		const idleState = electron.powerMonitor.getSystemIdleState(idleThresholdSeconds);
+		if (idleState === 'active') {
+			page.send('set-active');
+		} else {
+			page.send('set-idle');
+		}
 	}, idleCheckInterval);
 });
 

app/main/linuxupdater.ts

@@ -1,11 +1,11 @@
-import { app, Notification } from 'electron';
+import {app, Notification} from 'electron';
 
-import request = require('request');
-import semver = require('semver');
-import ConfigUtil = require('../renderer/js/utils/config-util');
-import ProxyUtil = require('../renderer/js/utils/proxy-util');
-import LinuxUpdateUtil = require('../renderer/js/utils/linux-update-util');
-import Logger = require('../renderer/js/utils/logger-util');
+import request from 'request';
+import semver from 'semver';
+import * as ConfigUtil from '../renderer/js/utils/config-util';
+import * as ProxyUtil from '../renderer/js/utils/proxy-util';
+import * as LinuxUpdateUtil from '../renderer/js/utils/linux-update-util';
+import Logger from '../renderer/js/utils/logger-util';
 
 const logger = new Logger({
 	file: 'linux-update-util.log',
@@ -24,20 +24,24 @@ export function linuxUpdateNotification(): void {
 		ecdhCurve: 'auto'
 	};
 
-	request(options, (error: any, response: any, body: any) => {
+	request(options, (error, response: request.Response, body: string) => {
 		if (error) {
 			logger.error('Linux update error.');
 			logger.error(error);
 			return;
 		}
+
 		if (response.statusCode < 400) {
 			const data = JSON.parse(body);
 			const latestVersion = ConfigUtil.getConfigItem('betaUpdate') ? data[0].tag_name : data.tag_name;
+			if (typeof latestVersion !== 'string') {
+				throw new TypeError('Expected string for tag_name');
+			}
 
 			if (semver.gt(latestVersion, app.getVersion())) {
 				const notified = LinuxUpdateUtil.getUpdateItem(latestVersion);
 				if (notified === null) {
-					new Notification({title: 'Zulip Update', body: 'A new version ' + latestVersion + ' is available. Please update using your package manager.'}).show();
+					new Notification({title: 'Zulip Update', body: `A new version ${latestVersion} is available. Please update using your package manager.`}).show();
 					LinuxUpdateUtil.setUpdateItem(latestVersion, true);
 				}
 			}

app/main/startup.ts

@@ -1,31 +1,32 @@
-'use strict';
-import { app } from 'electron';
+import {app} from 'electron';
 
-import AutoLaunch = require('auto-launch');
-import isDev = require('electron-is-dev');
-import ConfigUtil = require('../renderer/js/utils/config-util');
+import AutoLaunch from 'auto-launch';
+import isDev from 'electron-is-dev';
+import * as ConfigUtil from '../renderer/js/utils/config-util';
 
-export const setAutoLaunch = (AutoLaunchValue: boolean): void => {
+export const setAutoLaunch = async (AutoLaunchValue: boolean): Promise<void> => {
 	// Don't run this in development
 	if (isDev) {
 		return;
 	}
 
-	// On Mac, work around a bug in auto-launch where it opens a Terminal window
-	// See https://github.com/Teamwork/node-auto-launch/issues/28#issuecomment-222194437
-
-	const appPath = process.platform === 'darwin' ? app.getPath('exe').replace(/\.app\/Content.*/, '.app') : undefined; // Use the default
-
-	const ZulipAutoLauncher = new AutoLaunch({
-		name: 'Zulip',
-		path: appPath,
-		isHidden: false
-	});
 	const autoLaunchOption = ConfigUtil.getConfigItem('startAtLogin', AutoLaunchValue);
 
-	if (autoLaunchOption) {
-		ZulipAutoLauncher.enable();
+	// `setLoginItemSettings` doesn't support linux
+	if (process.platform === 'linux') {
+		const ZulipAutoLauncher = new AutoLaunch({
+			name: 'Zulip',
+			isHidden: false
+		});
+		if (autoLaunchOption) {
+			await ZulipAutoLauncher.enable();
+		} else {
+			await ZulipAutoLauncher.disable();
+		}
 	} else {
-		ZulipAutoLauncher.disable();
+		app.setLoginItemSettings({
+			openAtLogin: autoLaunchOption,
+			openAsHidden: false
+		});
 	}
 };

app/package.json

@@ -1,51 +0,0 @@
-{
-  "name": "zulip",
-  "productName": "Zulip",
-  "version": "4.0.2-beta",
-  "desktopName": "zulip.desktop",
-  "description": "Zulip Desktop App",
-  "license": "Apache-2.0",
-  "copyright": "Kandra Labs, Inc.",
-  "author": {
-    "name": "Kandra Labs, Inc.",
-    "email": "support@zulipchat.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/zulip/zulip-desktop.git"
-  },
-  "bugs": {
-    "url": "https://github.com/zulip/zulip-desktop/issues"
-  },
-  "main": "main/index.js",
-  "keywords": [
-    "Zulip",
-    "Group Chat app",
-    "electron-app",
-    "electron",
-    "Desktop app",
-    "InstantMessaging"
-  ],
-  "dependencies": {
-    "@electron-elements/send-feedback": "1.0.8",
-    "@sentry/electron": "0.14.0",
-    "adm-zip": "0.4.11",
-    "auto-launch": "5.0.5",
-    "backoff": "2.5.0",
-    "dotenv": "8.0.0",
-    "electron-is-dev": "0.3.0",
-    "electron-log": "2.2.14",
-    "electron-spellchecker": "1.1.2",
-    "electron-updater": "4.0.6",
-    "electron-window-state": "5.0.3",
-    "escape-html": "1.0.3",
-    "i18n": "0.8.3",
-    "node-json-db": "0.9.2",
-    "request": "2.85.0",
-    "semver": "5.4.1",
-    "wurl": "2.5.0"
-  },
-  "optionalDependencies": {
-    "node-mac-notifier": "1.1.0"
-  }
-}

app/renderer/about.html

@@ -14,33 +14,19 @@
             <div class="maintenance-info">
                 <p class="detail maintainer">
                     Maintained by
-                    <a onclick="linkInBrowser('website')">Zulip</a>
+                    <a href="https://zulipchat.com" target="_blank" rel="noopener noreferrer">Zulip</a>
                 </p>
                 <p class="detail license">
                     Available under the
-                    <a onclick="linkInBrowser('license')">Apache 2.0 License</a>
+                    <a href="https://github.com/zulip/zulip-desktop/blob/master/LICENSE" target="_blank" rel="noopener noreferrer">Apache 2.0 License</a>
                 </p>
             </div>
         </div>
         <script>
 
             const { app } = require('electron').remote;
-            const { shell } = require('electron');
             const version_tag = document.querySelector('#version');
             version_tag.innerHTML = 'v' + app.getVersion();
-
-            function linkInBrowser(type) {
-                let url;
-                switch (type) {
-                    case 'website':
-                        url = "https://zulipchat.com";
-                        break;
-                    case 'license':
-                        url = "https://github.com/zulip/zulip-desktop/blob/master/LICENSE";
-                        break;
-                }
-                shell.openExternal(url);
-            }
         </script>
         <script>require('./js/shared/preventdrag.js')</script>
     </body>

app/renderer/css/preference.css

@@ -724,3 +724,13 @@ i.open-network-button {
         margin-top: 10px;
     }
 }
+
+.lang-menu {
+    font-size: 13px;
+    font-weight: bold;
+    background: rgba(78, 191, 172, 1.000);
+    width: 100px;
+    height: 38px;
+    color: rgba(255, 255, 255, 1.000);
+    border-color: rgba(0, 0, 0, 0);
+}

app/renderer/js/clipboard-decrypter.ts

@@ -0,0 +1,82 @@
+import {clipboard} from 'electron';
+import crypto from 'crypto';
+
+// This helper is exposed via electron_bridge for use in the social
+// login flow.
+//
+// It consists of a key and a promised token.  The in-app page sends
+// the key to the server, and opens the user’s browser to a page where
+// they can log in and get a token encrypted to that key.  When the
+// user copies the encrypted token from their browser to the
+// clipboard, we decrypt it and resolve the promise.  The in-app page
+// then uses the decrypted token to log the user in within the app.
+//
+// The encryption is authenticated (AES-GCM) to guarantee that we
+// don’t leak anything from the user’s clipboard other than the token
+// intended for us.
+
+export class ClipboardDecrypterImpl implements ClipboardDecrypter {
+	version: number;
+	key: Uint8Array;
+	pasted: Promise<string>;
+
+	constructor(_: number) {
+		// At this time, the only version is 1.
+		this.version = 1;
+		this.key = crypto.randomBytes(32);
+		this.pasted = new Promise(resolve => {
+			let interval: NodeJS.Timeout | null = null;
+			const startPolling = () => {
+				if (interval === null) {
+					interval = setInterval(poll, 1000);
+				}
+
+				poll();
+			};
+
+			const stopPolling = () => {
+				if (interval !== null) {
+					clearInterval(interval);
+					interval = null;
+				}
+			};
+
+			const poll = () => {
+				let plaintext;
+
+				try {
+					const data = Buffer.from(clipboard.readText(), 'hex');
+					const iv = data.slice(0, 12);
+					const ciphertext = data.slice(12, -16);
+					const authTag = data.slice(-16);
+					const decipher = crypto.createDecipheriv(
+						'aes-256-gcm',
+						this.key,
+						iv,
+						{authTagLength: 16}
+					);
+					decipher.setAuthTag(authTag);
+					plaintext =
+						decipher.update(ciphertext, undefined, 'utf8') +
+						decipher.final('utf8');
+				} catch (_) {
+					// If the parsing or decryption failed in any way,
+					// the correct token hasn’t been copied yet; try
+					// again next time.
+					return;
+				}
+
+				window.removeEventListener('focus', startPolling);
+				window.removeEventListener('blur', stopPolling);
+				stopPolling();
+				resolve(plaintext);
+			};
+
+			window.addEventListener('focus', startPolling);
+			window.addEventListener('blur', stopPolling);
+			if (document.hasFocus()) {
+				startPolling();
+			}
+		});
+	}
+}

app/renderer/js/components/base.ts

@@ -1,11 +1,7 @@
-'use strict';
-
-class BaseComponent {
+export default class BaseComponent {
 	generateNodeFromTemplate(template: string): Element | null {
 		const wrapper = document.createElement('div');
 		wrapper.innerHTML = template;
 		return wrapper.firstElementChild;
 	}
 }
-
-export = BaseComponent;

app/renderer/js/components/functional-tab.ts

@@ -1,9 +1,13 @@
-'use strict';
+import Tab, {TabProps} from './tab';
 
-import Tab = require('./tab');
-
-class FunctionalTab extends Tab {
+export default class FunctionalTab extends Tab {
 	$closeButton: Element;
+
+	constructor(props: TabProps) {
+		super(props);
+		this.init();
+	}
+
 	template(): string {
 		return `<div class="tab functional-tab" data-tab-id="${this.props.tabIndex}">
 					<div class="server-tab-badge close-button">
@@ -15,12 +19,6 @@ class FunctionalTab extends Tab {
 				</div>`;
 	}
 
-	// TODO: Typescript - This type for props should be TabProps
-	constructor(props: any) {
-		super(props);
-		this.init();
-	}
-
 	init(): void {
 		this.$el = this.generateNodeFromTemplate(this.template());
 		if (this.props.name !== 'Settings') {
@@ -41,11 +39,9 @@ class FunctionalTab extends Tab {
 			this.$closeButton.classList.remove('active');
 		});
 
-		this.$closeButton.addEventListener('click', (e: Event) => {
+		this.$closeButton.addEventListener('click', (event: Event) => {
 			this.props.onDestroy();
-			e.stopPropagation();
+			event.stopPropagation();
 		});
 	}
 }
-
-export = FunctionalTab;

app/renderer/js/components/handle-external-link.ts

@@ -1,83 +1,60 @@
-import { ipcRenderer, remote } from 'electron';
+import {ipcRenderer, remote} from 'electron';
 
-import LinkUtil = require('../utils/link-util');
-import DomainUtil = require('../utils/domain-util');
-import ConfigUtil = require('../utils/config-util');
+import * as LinkUtil from '../utils/link-util';
+import * as ConfigUtil from '../utils/config-util';
+import type WebView from './webview';
 
-const { shell, app } = remote;
+const {shell, app} = remote;
 
 const dingSound = new Audio('../resources/sounds/ding.ogg');
 
-// TODO: TypeScript - Figure out a way to pass correct type here.
-function handleExternalLink(this: any, event: any): void {
-	const { url } = event;
-	const domainPrefix = DomainUtil.getDomain(this.props.index).url;
+export default function handleExternalLink(this: WebView, event: Electron.NewWindowEvent): void {
+	event.preventDefault();
+
+	const url = new URL(event.url);
 	const downloadPath = ConfigUtil.getConfigItem('downloadsPath', `${app.getPath('downloads')}`);
-	const shouldShowInFolder = ConfigUtil.getConfigItem('showDownloadFolder', false);
 
-	// Whitelist URLs which are allowed to be opened in the app
-	const {
-		isInternalUrl: isWhiteListURL,
-		isUploadsUrl: isUploadsURL
-	} = LinkUtil.isInternal(domainPrefix, url);
+	if (LinkUtil.isUploadsUrl(this.props.url, url)) {
+		ipcRenderer.send('downloadFile', url.href, downloadPath);
+		ipcRenderer.once('downloadFileCompleted', async (_event: Event, filePath: string, fileName: string) => {
+			const downloadNotification = new Notification('Download Complete', {
+				body: `Click to show ${fileName} in folder`,
+				silent: true // We'll play our own sound - ding.ogg
+			});
 
-	if (isWhiteListURL) {
-		event.preventDefault();
+			downloadNotification.addEventListener('click', () => {
+				// Reveal file in download folder
+				shell.showItemInFolder(filePath);
+			});
+			ipcRenderer.removeAllListeners('downloadFileFailed');
 
-		// Code to show pdf in a new BrowserWindow (currently commented out due to bug-upstream)
-		// Show pdf attachments in a new window
-		// if (LinkUtil.isPDF(url) && isUploadsURL) {
-		// 	ipcRenderer.send('pdf-view', url);
-		// 	return;
-		// }
+			// Play sound to indicate download complete
+			if (!ConfigUtil.getConfigItem('silent')) {
+				await dingSound.play();
+			}
+		});
 
-		// download txt, mp3, mp4 etc.. by using downloadURL in the
-		// main process which allows the user to save the files to their desktop
-		// and not trigger webview reload while image in webview will
-		// do nothing and will not save it
-
-		// Code to show pdf in a new BrowserWindow (currently commented out due to bug-upstream)
-		// if (!LinkUtil.isImage(url) && !LinkUtil.isPDF(url) && isUploadsURL) {
-		if (!LinkUtil.isImage(url) && isUploadsURL) {
-			ipcRenderer.send('downloadFile', url, downloadPath);
-			ipcRenderer.once('downloadFileCompleted', (_event: Event, filePath: string, fileName: string) => {
-				const downloadNotification = new Notification('Download Complete', {
-					body: shouldShowInFolder ? `Click to show ${fileName} in folder` : `Click to open ${fileName}`,
-					silent: true // We'll play our own sound - ding.ogg
-				});
-
-				// Play sound to indicate download complete
-				if (!ConfigUtil.getConfigItem('silent')) {
-					dingSound.play();
+		ipcRenderer.once('downloadFileFailed', (_event: Event, state: string) => {
+			// Automatic download failed, so show save dialog prompt and download
+			// through webview
+			// Only do this if it is the automatic download, otherwise show an error (so we aren't showing two save
+			// prompts right after each other)
+			// Check that the download is not cancelled by user
+			if (state !== 'cancelled') {
+				if (ConfigUtil.getConfigItem('promptDownload', false)) {
+					// We need to create a "new Notification" to display it, but just `Notification(...)` on its own
+					// doesn't work
+					new Notification('Download Complete', { // eslint-disable-line no-new
+						body: 'Download failed'
+					});
+				} else {
+					this.$el.downloadURL(url.href);
 				}
+			}
 
-				downloadNotification.addEventListener('click', () => {
-					if (shouldShowInFolder) {
-						// Reveal file in download folder
-						shell.showItemInFolder(filePath);
-					} else {
-						// Open file in the default native app
-						shell.openItem(filePath);
-					}
-				});
-				ipcRenderer.removeAllListeners('downloadFileFailed');
-			});
-
-			ipcRenderer.once('downloadFileFailed', () => {
-				// Automatic download failed, so show save dialog prompt and download
-				// through webview
-				this.$el.downloadURL(url);
-				ipcRenderer.removeAllListeners('downloadFileCompleted');
-			});
-			return;
-		}
-
-		// open internal urls inside the current webview.
-		this.$el.loadURL(url);
+			ipcRenderer.removeAllListeners('downloadFileCompleted');
+		});
 	} else {
-		event.preventDefault();
-		shell.openExternal(url);
+		(async () => LinkUtil.openBrowser(url))();
 	}
 }
-
-export = handleExternalLink;

app/renderer/js/components/server-tab.ts

@@ -1,13 +1,16 @@
-'use strict';
+import {ipcRenderer} from 'electron';
 
-import { ipcRenderer } from 'electron';
+import Tab, {TabProps} from './tab';
+import * as SystemUtil from '../utils/system-util';
 
-import Tab = require('./tab');
-import SystemUtil = require('../utils/system-util');
-
-class ServerTab extends Tab {
+export default class ServerTab extends Tab {
 	$badge: Element;
 
+	constructor(props: TabProps) {
+		super(props);
+		this.init();
+	}
+
 	template(): string {
 		return `<div class="tab" data-tab-id="${this.props.tabIndex}">
 					<div class="server-tooltip" style="display:none">${this.props.name}</div>
@@ -19,12 +22,6 @@ class ServerTab extends Tab {
 				</div>`;
 	}
 
-	// TODO: Typescript - This type for props should be TabProps
-	constructor(props: any) {
-		super(props);
-		this.init();
-	}
-
 	init(): void {
 		this.$el = this.generateNodeFromTemplate(this.template());
 		this.props.$root.append(this.$el);
@@ -64,5 +61,3 @@ class ServerTab extends Tab {
 		return shortcutText;
 	}
 }
-
-export = ServerTab;

app/renderer/js/components/tab.ts

@@ -1,14 +1,22 @@
-'use strict';
+import WebView from './webview';
+import BaseComponent from './base';
 
-import WebView = require('./webview');
-import BaseComponent = require('./base');
-
-// TODO: TypeScript - Type annotate props
-interface TabProps {
-	[key: string]: any;
+export interface TabProps {
+	role: string;
+	icon?: string;
+	name: string;
+	$root: Element;
+	onClick: () => void;
+	index: number;
+	tabIndex: number;
+	onHover?: () => void;
+	onHoverOut?: () => void;
+	webview: WebView;
+	materialIcon?: string;
+	onDestroy?: () => void;
 }
 
-class Tab extends BaseComponent {
+export default class Tab extends BaseComponent {
 	props: TabProps;
 	webview: WebView;
 	$el: Element;
@@ -40,9 +48,7 @@ class Tab extends BaseComponent {
 	}
 
 	destroy(): void {
-		this.$el.parentNode.removeChild(this.$el);
-		this.webview.$el.parentNode.removeChild(this.webview.$el);
+		this.$el.remove();
+		this.webview.$el.remove();
 	}
 }
-
-export = Tab;

app/renderer/js/components/webview.ts

@@ -1,40 +1,48 @@
-'use strict';
-import { remote } from 'electron';
+import {ipcRenderer, remote} from 'electron';
 
-import path = require('path');
-import fs = require('fs');
-import ConfigUtil = require('../utils/config-util');
-import SystemUtil = require('../utils/system-util');
-import BaseComponent = require('../components/base');
-import handleExternalLink = require('../components/handle-external-link');
+import path from 'path';
+import fs from 'fs';
+import * as ConfigUtil from '../utils/config-util';
+import * as SystemUtil from '../utils/system-util';
+import BaseComponent from './base';
+import handleExternalLink from './handle-external-link';
 
-const { app, dialog } = remote;
+const {app, dialog} = remote;
 
 const shouldSilentWebview = ConfigUtil.getConfigItem('silent');
 
-// TODO: TypeScript - Type annotate WebViewProps.
 interface WebViewProps {
-	[key: string]: any;
+	$root: Element;
+	index: number;
+	tabIndex: number;
+	url: string;
+	role: string;
+	name: string;
+	isActive: () => boolean;
+	switchLoading: (loading: boolean, url: string) => void;
+	onNetworkError: (index: number) => void;
+	nodeIntegration: boolean;
+	preload: boolean;
+	onTitleChange: () => void;
+	ignoreCerts?: boolean;
+	hasPermission?: (origin: string, permission: string) => boolean;
 }
 
-class WebView extends BaseComponent {
-	props: any;
+export default class WebView extends BaseComponent {
+	props: WebViewProps;
 	zoomFactor: number;
 	badgeCount: number;
 	loading: boolean;
 	customCSS: string;
 	$webviewsContainer: DOMTokenList;
 	$el: Electron.WebviewTag;
-
-	// This is required because in main.js we access WebView.method as
-	// webview[method].
-	[key: string]: any;
+	domReady?: Promise<void>;
 
 	constructor(props: WebViewProps) {
 		super();
 
 		this.props = props;
-		this.zoomFactor = 1.0;
+		this.zoomFactor = 1;
 		this.loading = true;
 		this.badgeCount = 0;
 		this.customCSS = ConfigUtil.getConfigItem('customCSS');
@@ -47,16 +55,18 @@ class WebView extends BaseComponent {
 					data-tab-id="${this.props.tabIndex}"
 					src="${this.props.url}"
 					${this.props.nodeIntegration ? 'nodeIntegration' : ''}
-					disablewebsecurity
 					${this.props.preload ? 'preload="js/preload.js"' : ''}
 					partition="persist:webviewsession"
 					name="${this.props.name}"
-					webpreferences="allowRunningInsecureContent, javascript=yes">
+					webpreferences="${this.props.nodeIntegration ? '' : 'contextIsolation, '}javascript=yes">
 				</webview>`;
 	}
 
 	init(): void {
 		this.$el = this.generateNodeFromTemplate(this.template()) as Electron.WebviewTag;
+		this.domReady = new Promise(resolve => {
+			this.$el.addEventListener('dom-ready', () => resolve(), true);
+		});
 		this.props.$root.append(this.$el);
 
 		this.registerListeners();
@@ -74,7 +84,7 @@ class WebView extends BaseComponent {
 		}
 
 		this.$el.addEventListener('page-title-updated', event => {
-			const { title } = event;
+			const {title} = event;
 			this.badgeCount = this.getBadgeCount(title);
 			this.props.onTitleChange();
 		});
@@ -84,6 +94,7 @@ class WebView extends BaseComponent {
 			if (isSettingPage) {
 				return;
 			}
+
 			this.canGoBackButton();
 		});
 
@@ -92,14 +103,14 @@ class WebView extends BaseComponent {
 		});
 
 		this.$el.addEventListener('page-favicon-updated', event => {
-			const { favicons } = event;
+			const {favicons} = event;
 
 			// This returns a string of favicons URL. If there is a PM counts in unread messages then the URL would be like
 			// https://chat.zulip.org/static/images/favicon/favicon-pms.png
 			if (favicons[0].indexOf('favicon-pms') > 0 && process.platform === 'darwin') {
 				// This api is only supported on macOS
 				app.dock.setBadge('●');
-				// bounce the dock
+				// Bounce the dock
 				if (ConfigUtil.getConfigItem('dockBouncing')) {
 					app.dock.bounce();
 				}
@@ -110,6 +121,7 @@ class WebView extends BaseComponent {
 			if (this.props.role === 'server') {
 				this.$el.classList.add('onload');
 			}
+
 			this.loading = false;
 			this.props.switchLoading(false, this.props.url);
 			this.show();
@@ -121,7 +133,7 @@ class WebView extends BaseComponent {
 		});
 
 		this.$el.addEventListener('did-fail-load', event => {
-			const { errorDescription } = event;
+			const {errorDescription} = event;
 			const hasConnectivityErr = SystemUtil.connectivityERR.includes(errorDescription);
 			if (hasConnectivityErr) {
 				console.error('error', errorDescription);
@@ -136,12 +148,6 @@ class WebView extends BaseComponent {
 			if (!isSettingPage) {
 				this.props.switchLoading(true, this.props.url);
 			}
-			let userAgent = SystemUtil.getUserAgent();
-			if (!userAgent) {
-				SystemUtil.setUserAgent(this.$el.getUserAgent());
-				userAgent = SystemUtil.getUserAgent();
-			}
-			this.$el.setUserAgent(userAgent);
 		});
 
 		this.$el.addEventListener('did-stop-loading', () => {
@@ -155,7 +161,7 @@ class WebView extends BaseComponent {
 	}
 
 	showNotificationSettings(): void {
-		this.$el.executeJavaScript('showNotificationSettings()');
+		ipcRenderer.sendTo(this.$el.getWebContentsId(), 'show-notification-settings');
 	}
 
 	show(): void {
@@ -181,26 +187,26 @@ class WebView extends BaseComponent {
 		this.focus();
 		this.props.onTitleChange();
 		// Injecting preload css in webview to override some css rules
-		this.$el.insertCSS(fs.readFileSync(path.join(__dirname, '/../../css/preload.css'), 'utf8'));
+		(async () => this.$el.insertCSS(fs.readFileSync(path.join(__dirname, '/../../css/preload.css'), 'utf8')))();
 
-		// get customCSS again from config util to avoid warning user again
+		// Get customCSS again from config util to avoid warning user again
 		this.customCSS = ConfigUtil.getConfigItem('customCSS');
 		if (this.customCSS) {
 			if (!fs.existsSync(this.customCSS)) {
 				this.customCSS = null;
 				ConfigUtil.setConfigItem('customCSS', null);
 
-				const errMsg = 'The custom css previously set is deleted!';
-				dialog.showErrorBox('custom css file deleted!', errMsg);
+				const errorMessage = 'The custom css previously set is deleted!';
+				dialog.showErrorBox('custom css file deleted!', errorMessage);
 				return;
 			}
 
-			this.$el.insertCSS(fs.readFileSync(path.resolve(__dirname, this.customCSS), 'utf8'));
+			(async () => this.$el.insertCSS(fs.readFileSync(path.resolve(__dirname, this.customCSS), 'utf8')))();
 		}
 	}
 
 	focus(): void {
-		// focus Webview and it's contents when Window regain focus.
+		// Focus Webview and it's contents when Window regain focus.
 		const webContents = this.$el.getWebContents();
 		// HACK: webContents.isFocused() seems to be true even without the element
 		// being in focus. So, we check against `document.activeElement`.
@@ -238,16 +244,16 @@ class WebView extends BaseComponent {
 	}
 
 	zoomActualSize(): void {
-		this.zoomFactor = 1.0;
+		this.zoomFactor = 1;
 		this.$el.setZoomFactor(this.zoomFactor);
 	}
 
 	logOut(): void {
-		this.$el.executeJavaScript('logout()');
+		ipcRenderer.sendTo(this.$el.getWebContentsId(), 'logout');
 	}
 
 	showShortcut(): void {
-		this.$el.executeJavaScript('shortcut()');
+		ipcRenderer.sendTo(this.$el.getWebContentsId(), 'shortcut');
 	}
 
 	openDevTools(): void {
@@ -289,9 +295,8 @@ class WebView extends BaseComponent {
 		this.init();
 	}
 
-	send(channel: string, ...param: any[]): void {
-		this.$el.send(channel, ...param);
+	async send(channel: string, ...parameters: unknown[]): Promise<void> {
+		await this.domReady;
+		await this.$el.send(channel, ...parameters);
 	}
 }
-
-export = WebView;

app/renderer/js/electron-bridge.ts

@@ -1,14 +1,13 @@
-import { ipcRenderer } from 'electron';
+import {ipcRenderer} from 'electron';
 
-import events = require('events');
+import {EventEmitter} from 'events';
+
+import {ClipboardDecrypterImpl} from './clipboard-decrypter';
+import {NotificationData, newNotification} from './notification';
 
 type ListenerType = ((...args: any[]) => void);
 
-// we have and will have some non camelcase stuff
-// while working with zulip so just turning the rule off
-// for the whole file.
-/* eslint-disable @typescript-eslint/camelcase */
-class ElectronBridge extends events {
+class ElectronBridgeImpl extends EventEmitter implements ElectronBridge {
 	send_notification_reply_message_supported: boolean;
 	idle_on_system: boolean;
 	last_active_on_system: number;
@@ -23,16 +22,37 @@ class ElectronBridge extends events {
 		this.last_active_on_system = Date.now();
 	}
 
-	send_event(eventName: string | symbol, ...args: any[]): void {
+	send_event = (eventName: string | symbol, ...args: unknown[]): void => {
 		this.emit(eventName, ...args);
-	}
+	};
 
-	on_event(eventName: string, listener: ListenerType): void {
+	on_event = (eventName: string, listener: ListenerType): void => {
 		this.on(eventName, listener);
-	}
+	};
+
+	new_notification = (
+		title: string,
+		options: NotificationOptions | undefined,
+		dispatch: (type: string, eventInit: EventInit) => boolean
+	): NotificationData =>
+		newNotification(title, options, dispatch);
+
+	get_idle_on_system = (): boolean => this.idle_on_system;
+
+	get_last_active_on_system = (): number => this.last_active_on_system;
+
+	get_send_notification_reply_message_supported = (): boolean =>
+		this.send_notification_reply_message_supported;
+
+	set_send_notification_reply_message_supported = (value: boolean): void => {
+		this.send_notification_reply_message_supported = value;
+	};
+
+	decrypt_clipboard = (version: number): ClipboardDecrypterImpl =>
+		new ClipboardDecrypterImpl(version);
 }
 
-const electron_bridge = new ElectronBridge();
+const electron_bridge = new ElectronBridgeImpl();
 
 electron_bridge.on('total_unread_count', (...args) => {
 	ipcRenderer.send('unread-count', ...args);
@@ -43,17 +63,19 @@ electron_bridge.on('realm_name', realmName => {
 	ipcRenderer.send('realm-name-changed', serverURL, realmName);
 });
 
-electron_bridge.on('realm_icon_url', iconURL => {
+electron_bridge.on('realm_icon_url', (iconURL: unknown) => {
+	if (typeof iconURL !== 'string') {
+		throw new TypeError('Expected string for iconURL');
+	}
+
 	const serverURL = location.origin;
 	iconURL = iconURL.includes('http') ? iconURL : `${serverURL}${iconURL}`;
 	ipcRenderer.send('realm-icon-changed', serverURL, iconURL);
 });
 
-// this follows node's idiomatic implementation of event
+// This follows node's idiomatic implementation of event
 // emitters to make event handling more simpler instead of using
 // functions zulip side will emit event using ElectronBrigde.send_event
 // which is alias of .emit and on this side we can handle the data by adding
 // a listener for the event.
-export = electron_bridge;
-
-/* eslint-enable @typescript-eslint/camelcase */
+export default electron_bridge;

app/renderer/js/feedback.ts

@@ -1,19 +1,17 @@
-import { remote } from 'electron';
+import {remote} from 'electron';
 import SendFeedback from '@electron-elements/send-feedback';
 
-import path = require('path');
-import fs = require('fs');
+import path from 'path';
+import fs from 'fs';
 
-const { app } = remote;
+const {app} = remote;
 
-interface SendFeedback extends HTMLElement {
-	[key: string]: any;
-}
+customElements.define('send-feedback', SendFeedback);
+export const sendFeedback: SendFeedback = document.querySelector('send-feedback');
+export const feedbackHolder = sendFeedback.parentElement;
 
-type SendFeedbackType = SendFeedback;
-
-// make the button color match zulip app's theme
-SendFeedback.customStyles = `
+// Make the button color match zulip app's theme
+sendFeedback.customStyles = `
 button:hover, button:focus {
   border-color: #4EBFAC;
   color: #4EBFAC;
@@ -30,16 +28,26 @@ button {
 }
 `;
 
-customElements.define('send-feedback', SendFeedback);
-export const sendFeedback: SendFeedbackType = document.querySelector('send-feedback');
-export const feedbackHolder = sendFeedback.parentElement;
+/* eslint-disable no-multi-str */
 
 // customize the fields of custom elements
 sendFeedback.title = 'Report Issue';
 sendFeedback.titleLabel = 'Issue title:';
 sendFeedback.titlePlaceholder = 'Enter issue title';
 sendFeedback.textareaLabel = 'Describe the issue:';
-sendFeedback.textareaPlaceholder = 'Succinctly describe your issue and steps to reproduce it...';
+sendFeedback.textareaPlaceholder = 'Succinctly describe your issue and steps to reproduce it...\n\n\
+---\n\
+<!-- Please Include: -->\n\
+- **Operating System**:\n\
+  - [ ] Windows\n\
+  - [ ] Linux/Ubuntu\n\
+  - [ ] macOS\n\
+- **Clear steps to reproduce the issue**:\n\
+- **Relevant error messages and/or screenshots**:\n\
+';
+
+/* eslint-enable no-multi-str */
+
 sendFeedback.buttonLabel = 'Report Issue';
 sendFeedback.loaderSuccessText = '';
 
@@ -47,10 +55,10 @@ sendFeedback.useReporter('emailReporter', {
 	email: 'akash@zulipchat.com'
 });
 
-feedbackHolder.addEventListener('click', (e: Event) => {
-	// only remove the class if the grey out faded
+feedbackHolder.addEventListener('click', (event: Event) => {
+	// Only remove the class if the grey out faded
 	// part is clicked and not the feedback element itself
-	if (e.target === e.currentTarget) {
+	if (event.target === event.currentTarget) {
 		feedbackHolder.classList.remove('show');
 	}
 });

app/renderer/js/injected.ts

@@ -0,0 +1,135 @@
+'use strict';
+
+interface CompatElectronBridge extends ElectronBridge {
+	readonly idle_on_system: boolean;
+	readonly last_active_on_system: number;
+	send_notification_reply_message_supported: boolean;
+}
+
+(() => {
+	const zulipWindow = window as typeof window & {
+		electron_bridge: CompatElectronBridge;
+		narrow: {
+			by_subject?: (target_id: number, opts: {trigger?: string}) => void;
+			by_topic?: (target_id: number, opts: {trigger?: string}) => void;
+		};
+		page_params?: {
+			default_language?: string;
+		};
+		raw_electron_bridge: ElectronBridge;
+	};
+
+	const electron_bridge: CompatElectronBridge = {
+		...zulipWindow.raw_electron_bridge,
+
+		get idle_on_system(): boolean {
+			return this.get_idle_on_system();
+		},
+
+		get last_active_on_system(): number {
+			return this.get_last_active_on_system();
+		},
+
+		get send_notification_reply_message_supported(): boolean {
+			return this.get_send_notification_reply_message_supported();
+		},
+
+		set send_notification_reply_message_supported(value: boolean) {
+			this.set_send_notification_reply_message_supported(value);
+		}
+	};
+
+	zulipWindow.electron_bridge = electron_bridge;
+
+	(async () => {
+		if (document.readyState === 'loading') {
+			await new Promise(resolve => {
+				document.addEventListener('DOMContentLoaded', () => {
+					resolve();
+				});
+			});
+		}
+
+		const {page_params} = zulipWindow;
+		if (page_params) {
+			electron_bridge.send_event('zulip-loaded', {
+				serverLanguage: page_params.default_language
+			});
+		}
+	})();
+
+	electron_bridge.on_event('narrow-by-topic', (id: number) => {
+		const {narrow} = zulipWindow;
+		const narrowByTopic = narrow.by_topic || narrow.by_subject;
+		narrowByTopic(id, {trigger: 'notification'});
+	});
+
+	function attributeListener<T extends EventTarget>(type: string): PropertyDescriptor {
+		const symbol = Symbol('on' + type);
+
+		function listener(this: T, ev: Event): void {
+			if ((this as any)[symbol].call(this, ev) === false) {
+				ev.preventDefault();
+			}
+		}
+
+		return {
+			configurable: true,
+			enumerable: true,
+			get(this: T) {
+				return (this as any)[symbol];
+			},
+			set(this: T, value: unknown) {
+				if (typeof value === 'function') {
+					if (!(symbol in this)) {
+						this.addEventListener(type, listener);
+					}
+
+					(this as any)[symbol] = value;
+				} else if (symbol in this) {
+					this.removeEventListener(type, listener);
+					delete (this as any)[symbol];
+				}
+			}
+		};
+	}
+
+	const NativeNotification = Notification;
+
+	class InjectedNotification extends EventTarget {
+		constructor(title: string, options?: NotificationOptions) {
+			super();
+			Object.assign(
+				this,
+				electron_bridge.new_notification(title, options, (type: string, eventInit: EventInit) =>
+					this.dispatchEvent(new Event(type, eventInit))
+				)
+			);
+		}
+
+		static get maxActions(): number {
+			return NativeNotification.maxActions;
+		}
+
+		static get permission(): NotificationPermission {
+			return NativeNotification.permission;
+		}
+
+		static async requestPermission(callback?: NotificationPermissionCallback): Promise<NotificationPermission> {
+			if (callback) {
+				callback(await Promise.resolve(NativeNotification.permission));
+			}
+
+			return NativeNotification.permission;
+		}
+	}
+
+	Object.defineProperties(InjectedNotification.prototype, {
+		onclick: attributeListener('click'),
+		onclose: attributeListener('close'),
+		onerror: attributeListener('error'),
+		onshow: attributeListener('show')
+	});
+
+	window.Notification = InjectedNotification as any;
+})();

app/renderer/js/main.ts

@@ -1,27 +1,27 @@
-'use strict';
+import {ipcRenderer, remote, clipboard} from 'electron';
+import {feedbackHolder} from './feedback';
 
-import { ipcRenderer, remote, clipboard, shell } from 'electron';
-import { feedbackHolder } from './feedback';
-
-import path = require('path');
-import escape = require('escape-html');
-import isDev = require('electron-is-dev');
-const { session, app, Menu, dialog } = remote;
+import path from 'path';
+import escape from 'escape-html';
+import isDev from 'electron-is-dev';
+const {session, app, Menu, dialog} = remote;
 
 // eslint-disable-next-line import/no-unassigned-import
-require('./tray');
+import './tray';
 
-import DomainUtil = require('./utils/domain-util');
-import WebView = require('./components/webview');
-import ServerTab = require('./components/server-tab');
-import FunctionalTab = require('./components/functional-tab');
-import ConfigUtil = require('./utils/config-util');
-import DNDUtil = require('./utils/dnd-util');
-import ReconnectUtil = require('./utils/reconnect-util');
-import Logger = require('./utils/logger-util');
-import CommonUtil = require('./utils/common-util');
-import EnterpriseUtil = require('./utils/enterprise-util');
-import Messages = require('./../../resources/messages');
+import * as DomainUtil from './utils/domain-util';
+import WebView from './components/webview';
+import ServerTab from './components/server-tab';
+import FunctionalTab from './components/functional-tab';
+import * as ConfigUtil from './utils/config-util';
+import * as DNDUtil from './utils/dnd-util';
+import ReconnectUtil from './utils/reconnect-util';
+import Logger from './utils/logger-util';
+import * as CommonUtil from './utils/common-util';
+import * as EnterpriseUtil from './utils/enterprise-util';
+import * as LinkUtil from './utils/link-util';
+import * as Messages from '../../resources/messages';
+import type {DNDSettings} from './utils/dnd-util';
 
 interface FunctionalTabProps {
 	name: string;
@@ -29,11 +29,7 @@ interface FunctionalTabProps {
 	url: string;
 }
 
-interface AnyObject {
-	[key: string]: any;
-}
-
-interface SettingsOptions {
+interface SettingsOptions extends DNDSettings {
 	autoHideMenubar: boolean;
 	trayIcon: boolean;
 	useManualProxy: boolean;
@@ -43,25 +39,17 @@ interface SettingsOptions {
 	startAtLogin: boolean;
 	startMinimized: boolean;
 	enableSpellchecker: boolean;
-	showNotification: boolean;
 	autoUpdate: boolean;
 	betaUpdate: boolean;
 	errorReporting: boolean;
 	customCSS: boolean;
-	silent: boolean;
 	lastActiveTab: number;
 	dnd: boolean;
-	dndPreviousSettings: {
-		showNotification: boolean;
-		silent: boolean;
-		flashTaskbarOnMessage?: boolean;
-	};
+	dndPreviousSettings: DNDSettings;
 	downloadsPath: string;
-	showDownloadFolder: boolean;
 	quitOnClose: boolean;
-	flashTaskbarOnMessage?: boolean;
+	promptDownload: boolean;
 	dockBouncing?: boolean;
-	loading?: AnyObject;
 }
 
 const logger = new Logger({
@@ -70,7 +58,7 @@ const logger = new Logger({
 });
 
 const rendererDirectory = path.resolve(__dirname, '..');
-type ServerOrFunctionalTab = ServerTab | FunctionalTab;
+export type ServerOrFunctionalTab = ServerTab | FunctionalTab;
 
 class ServerManagerView {
 	$addServerButton: HTMLButtonElement;
@@ -91,10 +79,10 @@ class ServerManagerView {
 	$sidebar: Element;
 	$fullscreenPopup: Element;
 	$fullscreenEscapeKey: string;
-	loading: AnyObject;
+	loading: Set<string>;
 	activeTabIndex: number;
 	tabs: ServerOrFunctionalTab[];
-	functionalTabs: AnyObject;
+	functionalTabs: Map<string, number>;
 	tabIndex: number;
 	presetOrgs: string[];
 	constructor() {
@@ -129,54 +117,54 @@ class ServerManagerView {
 		this.$fullscreenEscapeKey = process.platform === 'darwin' ? '^⌘F' : 'F11';
 		this.$fullscreenPopup.innerHTML = `Press ${this.$fullscreenEscapeKey} to exit full screen`;
 
-		this.loading = {};
+		this.loading = new Set();
 		this.activeTabIndex = -1;
 		this.tabs = [];
 		this.presetOrgs = [];
-		this.functionalTabs = {};
+		this.functionalTabs = new Map();
 		this.tabIndex = 0;
 	}
 
-	init(): void {
-		this.loadProxy().then(() => {
-			this.initDefaultSettings();
-			this.initSidebar();
-			if (EnterpriseUtil.configFile) {
-				this.initPresetOrgs();
-			}
-			this.initTabs();
-			this.initActions();
-			this.registerIpcs();
-		});
+	async init(): Promise<void> {
+		await this.loadProxy();
+		this.initDefaultSettings();
+		this.initSidebar();
+		this.removeUAfromDisk();
+		if (EnterpriseUtil.hasConfigFile()) {
+			await this.initPresetOrgs();
+		}
+
+		await this.initTabs();
+		this.initActions();
+		this.registerIpcs();
 	}
 
-	loadProxy(): Promise<boolean> {
-		return new Promise(resolve => {
-			// To change proxyEnable to useManualProxy in older versions
-			const proxyEnabledOld = ConfigUtil.isConfigItemExists('useProxy');
-			if (proxyEnabledOld) {
-				const proxyEnableOldState = ConfigUtil.getConfigItem('useProxy');
-				if (proxyEnableOldState) {
-					ConfigUtil.setConfigItem('useManualProxy', true);
-				}
-				ConfigUtil.removeConfigItem('useProxy');
+	async loadProxy(): Promise<void> {
+		// To change proxyEnable to useManualProxy in older versions
+		const proxyEnabledOld = ConfigUtil.isConfigItemExists('useProxy');
+		if (proxyEnabledOld) {
+			const proxyEnableOldState = ConfigUtil.getConfigItem('useProxy');
+			if (proxyEnableOldState) {
+				ConfigUtil.setConfigItem('useManualProxy', true);
 			}
 
-			const proxyEnabled = ConfigUtil.getConfigItem('useManualProxy') || ConfigUtil.getConfigItem('useSystemProxy');
-			if (proxyEnabled) {
-				session.fromPartition('persist:webviewsession').setProxy({
-					pacScript: ConfigUtil.getConfigItem('proxyPAC', ''),
-					proxyRules: ConfigUtil.getConfigItem('proxyRules', ''),
-					proxyBypassRules: ConfigUtil.getConfigItem('proxyBypass', '')
-				}, resolve);
-			} else {
-				session.fromPartition('persist:webviewsession').setProxy({
-					pacScript: '',
-					proxyRules: '',
-					proxyBypassRules: ''
-				}, resolve);
-			}
-		});
+			ConfigUtil.removeConfigItem('useProxy');
+		}
+
+		const proxyEnabled = ConfigUtil.getConfigItem('useManualProxy') || ConfigUtil.getConfigItem('useSystemProxy');
+		if (proxyEnabled) {
+			await session.fromPartition('persist:webviewsession').setProxy({
+				pacScript: ConfigUtil.getConfigItem('proxyPAC', ''),
+				proxyRules: ConfigUtil.getConfigItem('proxyRules', ''),
+				proxyBypassRules: ConfigUtil.getConfigItem('proxyBypass', '')
+			});
+		} else {
+			await session.fromPartition('persist:webviewsession').setProxy({
+				pacScript: '',
+				proxyRules: '',
+				proxyBypassRules: ''
+			});
+		}
 	}
 
 	// Settings are initialized only when user clicks on General/Server/Network section settings
@@ -207,8 +195,8 @@ class ServerManagerView {
 				silent: false
 			},
 			downloadsPath: `${app.getPath('downloads')}`,
-			showDownloadFolder: false,
-			quitOnClose: false
+			quitOnClose: false,
+			promptDownload: false
 		};
 
 		// Platform specific settings
@@ -228,13 +216,12 @@ class ServerManagerView {
 			settingOptions.autoHideMenubar = false;
 		}
 
-		for (const i in settingOptions) {
-			const setting = i as keyof SettingsOptions;
-			// give preference to defaults defined in global_config.json
+		for (const [setting, value] of Object.entries(settingOptions)) {
+			// Give preference to defaults defined in global_config.json
 			if (EnterpriseUtil.configItemExists(setting)) {
 				ConfigUtil.setConfigItem(setting, EnterpriseUtil.getConfigItem(setting), true);
 			} else if (ConfigUtil.getConfigItem(setting) === null) {
-				ConfigUtil.setConfigItem(setting, settingOptions[setting]);
+				ConfigUtil.setConfigItem(setting, value);
 			}
 		}
 	}
@@ -244,110 +231,122 @@ class ServerManagerView {
 		this.toggleSidebar(showSidebar);
 	}
 
-	async queueDomain(domain: any): Promise<boolean> {
-		// allows us to start adding multiple domains to the app simultaneously
+	// Remove the stale UA string from the disk if the app is not freshly
+	// installed.  This should be removed in a further release.
+	removeUAfromDisk(): void {
+		ConfigUtil.removeConfigItem('userAgent');
+	}
+
+	async queueDomain(domain: string): Promise<boolean> {
+		// Allows us to start adding multiple domains to the app simultaneously
 		// promise of addition resolves in both cases, but we consider it rejected
 		// if the resolved value is false
 		try {
 			const serverConf = await DomainUtil.checkDomain(domain);
 			await DomainUtil.addDomain(serverConf);
 			return true;
-		} catch (err) {
-			logger.error(err);
-			logger.error('Could not add ' + domain + '. Please contact your system administrator.');
+		} catch (error) {
+			logger.error(error);
+			logger.error(`Could not add ${domain}. Please contact your system administrator.`);
 			return false;
 		}
 	}
 
 	async initPresetOrgs(): Promise<void> {
-		// read preset organizations from global_config.json and queues them
+		// Read preset organizations from global_config.json and queues them
 		// for addition to the app's domains
 		const preAddedDomains = DomainUtil.getDomains();
 		this.presetOrgs = EnterpriseUtil.getConfigItem('presetOrganizations', []);
-		// set to true if at least one new domain is added
+		// Set to true if at least one new domain is added
 		const domainPromises = [];
 		for (const url of this.presetOrgs) {
 			if (DomainUtil.duplicateDomain(url)) {
 				continue;
 			}
+
 			domainPromises.push(this.queueDomain(url));
 		}
+
 		const domainsAdded = await Promise.all(domainPromises);
 		if (domainsAdded.includes(true)) {
-			// at least one domain was resolved
+			// At least one domain was resolved
 			if (preAddedDomains.length > 0) {
-				// user already has servers added
+				// User already has servers added
 				// ask them before reloading the app
-				dialog.showMessageBox({
+				const {response} = await dialog.showMessageBox({
 					type: 'question',
 					buttons: ['Yes', 'Later'],
 					defaultId: 0,
 					message: 'New server' + (domainsAdded.length > 1 ? 's' : '') + ' added. Reload app now?'
-				}, response => {
-					if (response === 0) {
-						ipcRenderer.send('reload-full-app');
-					}
 				});
+				if (response === 0) {
+					ipcRenderer.send('reload-full-app');
+				}
 			} else {
 				ipcRenderer.send('reload-full-app');
 			}
 		} else if (domainsAdded.length > 0) {
-			// find all orgs that failed
+			// Find all orgs that failed
 			const failedDomains: string[] = [];
 			for (const org of this.presetOrgs) {
 				if (DomainUtil.duplicateDomain(org)) {
 					continue;
 				}
+
 				failedDomains.push(org);
 			}
-			const { title, content } = Messages.enterpriseOrgError(domainsAdded.length, failedDomains);
+
+			const {title, content} = Messages.enterpriseOrgError(domainsAdded.length, failedDomains);
 			dialog.showErrorBox(title, content);
 			if (DomainUtil.getDomains().length === 0) {
-				// no orgs present, stop showing loading gif
-				this.openSettings('AddServer');
+				// No orgs present, stop showing loading gif
+				await this.openSettings('AddServer');
 			}
 		}
 	}
 
-	initTabs(): void {
+	async initTabs(): Promise<void> {
 		const servers = DomainUtil.getDomains();
 		if (servers.length > 0) {
-			for (let i = 0; i < servers.length; i++) {
-				this.initServer(servers[i], i);
+			for (const [i, server] of servers.entries()) {
+				this.initServer(server, i);
 			}
+
 			// Open last active tab
 			let lastActiveTab = ConfigUtil.getConfigItem('lastActiveTab');
 			if (lastActiveTab >= servers.length) {
 				lastActiveTab = 0;
 			}
-			// checkDomain() and webview.load() for lastActiveTab before the others
-			DomainUtil.updateSavedServer(servers[lastActiveTab].url, lastActiveTab);
+
+			// `checkDomain()` and `webview.load()` for lastActiveTab before the others
+			await DomainUtil.updateSavedServer(servers[lastActiveTab].url, lastActiveTab);
 			this.activateTab(lastActiveTab);
-			for (let i = 0; i < servers.length; i++) {
-				// after the lastActiveTab is activated, we load the others in the background
+			await Promise.all(servers.map(async (server, i) => {
+				// After the lastActiveTab is activated, we load the others in the background
 				// without activating them, to prevent flashing of server icons
 				if (i === lastActiveTab) {
-					continue;
+					return;
 				}
-				DomainUtil.updateSavedServer(servers[i].url, i);
+
+				await DomainUtil.updateSavedServer(server.url, i);
 				this.tabs[i].webview.load();
-			}
+			}));
 			// Remove focus from the settings icon at sidebar bottom
 			this.$settingsButton.classList.remove('active');
 		} else if (this.presetOrgs.length === 0) {
-			// not attempting to add organisations in the background
-			this.openSettings('AddServer');
+			// Not attempting to add organisations in the background
+			await this.openSettings('AddServer');
 		} else {
 			this.showLoading(true);
 		}
 	}
 
-	initServer(server: any, index: number): void {
+	initServer(server: DomainUtil.ServerConf, index: number): void {
 		const tabIndex = this.getTabIndex();
 		this.tabs.push(new ServerTab({
 			role: 'server',
 			icon: server.icon,
-			name: server.alias,
+			name: CommonUtil.decodeString(server.alias),
 			$root: this.$tabsContainer,
 			onClick: this.activateLastTab.bind(this, index),
 			index,
@@ -361,16 +360,20 @@ class ServerManagerView {
 				url: server.url,
 				role: 'server',
 				name: CommonUtil.decodeString(server.alias),
+				ignoreCerts: server.ignoreCerts,
+				hasPermission: (origin: string, permission: string) =>
+					origin === server.url && permission === 'notifications',
 				isActive: () => {
 					return index === this.activeTabIndex;
 				},
 				switchLoading: (loading: boolean, url: string) => {
-					if (!loading && this.loading[url]) {
-						this.loading[url] = false;
-					} else if (loading && !this.loading[url]) {
-						this.loading[url] = true;
+					if (loading) {
+						this.loading.add(url);
+					} else {
+						this.loading.delete(url);
 					}
-					this.showLoading(this.loading[this.tabs[this.activeTabIndex].webview.props.url]);
+
+					this.showLoading(this.loading.has(this.tabs[this.activeTabIndex].webview.props.url));
 				},
 				onNetworkError: (index: number) => this.openNetworkTroubleshooting(index),
 				onTitleChange: this.updateBadge.bind(this),
@@ -378,7 +381,7 @@ class ServerManagerView {
 				preload: true
 			})
 		}));
-		this.loading[server.url] = true;
+		this.loading.add(server.url);
 	}
 
 	initActions(): void {
@@ -394,6 +397,7 @@ class ServerManagerView {
 			if ($serverImg.src.includes('img/icon.png')) {
 				this.displayInitialCharLogo($serverImg, index);
 			}
+
 			$serverImg.addEventListener('error', () => {
 				this.displayInitialCharLogo($serverImg, index);
 			});
@@ -408,11 +412,11 @@ class ServerManagerView {
 		this.$reloadButton.addEventListener('click', () => {
 			this.tabs[this.activeTabIndex].webview.reload();
 		});
-		this.$addServerButton.addEventListener('click', () => {
-			this.openSettings('AddServer');
+		this.$addServerButton.addEventListener('click', async () => {
+			await this.openSettings('AddServer');
 		});
-		this.$settingsButton.addEventListener('click', () => {
-			this.openSettings('General');
+		this.$settingsButton.addEventListener('click', async () => {
+			await this.openSettings('General');
 		});
 		this.$backButton.addEventListener('click', () => {
 			this.tabs[this.activeTabIndex].webview.back();
@@ -442,10 +446,9 @@ class ServerManagerView {
 	}
 
 	displayInitialCharLogo($img: HTMLImageElement, index: number): void {
-		/*
-			index parameter needed because webview[data-tab-id] can increment
-			beyond size of sidebar org array and throw error
-		*/
+		// The index parameter is needed because webview[data-tab-id] can
+		// increment beyond the size of the sidebar org array and throw an
+		// error
 
 		const $altIcon = document.createElement('div');
 		const $parent = $img.parentElement;
@@ -463,7 +466,7 @@ class ServerManagerView {
 		$altIcon.classList.add('server-icon');
 		$altIcon.classList.add('alt-icon');
 
-		$parent.removeChild($img);
+		$img.remove();
 		$parent.append($altIcon);
 
 		this.addContextMenu($altIcon as HTMLImageElement, index);
@@ -477,8 +480,8 @@ class ServerManagerView {
 			// as that of its parent element.
 			// This needs to handled only for the add server tooltip and not others.
 			if (addServer) {
-				const { top } = SidebarButton.getBoundingClientRect();
-				SidebarTooltip.style.top = top + 'px';
+				const {top} = SidebarButton.getBoundingClientRect();
+				SidebarTooltip.style.top = `${top}px`;
 			}
 		});
 		SidebarButton.addEventListener('mouseout', () => {
@@ -487,14 +490,14 @@ class ServerManagerView {
 	}
 
 	onHover(index: number): void {
-		// this.$serverIconTooltip[index].innerHTML already has realm name, so we are just
+		// `this.$serverIconTooltip[index].innerHTML` already has realm name, so we are just
 		// removing the style.
 		this.$serverIconTooltip[index].removeAttribute('style');
 		// To handle position of servers' tooltip due to scrolling of list of organizations
 		// This could not be handled using CSS, hence the top of the tooltip is made same
 		// as that of its parent element.
-		const { top } = this.$serverIconTooltip[index].parentElement.getBoundingClientRect();
-		this.$serverIconTooltip[index].style.top = top + 'px';
+		const {top} = this.$serverIconTooltip[index].parentElement.getBoundingClientRect();
+		this.$serverIconTooltip[index].style.top = `${top}px`;
 	}
 
 	onHoverOut(index: number): void {
@@ -502,12 +505,12 @@ class ServerManagerView {
 	}
 
 	openFunctionalTab(tabProps: FunctionalTabProps): void {
-		if (this.functionalTabs[tabProps.name] !== undefined) {
-			this.activateTab(this.functionalTabs[tabProps.name]);
+		if (this.functionalTabs.has(tabProps.name)) {
+			this.activateTab(this.functionalTabs.get(tabProps.name));
 			return;
 		}
 
-		this.functionalTabs[tabProps.name] = this.tabs.length;
+		this.functionalTabs.set(tabProps.name, this.tabs.length);
 
 		const tabIndex = this.getTabIndex();
 
@@ -516,27 +519,28 @@ class ServerManagerView {
 			materialIcon: tabProps.materialIcon,
 			name: tabProps.name,
 			$root: this.$tabsContainer,
-			index: this.functionalTabs[tabProps.name],
+			index: this.functionalTabs.get(tabProps.name),
 			tabIndex,
-			onClick: this.activateTab.bind(this, this.functionalTabs[tabProps.name]),
-			onDestroy: this.destroyTab.bind(this, tabProps.name, this.functionalTabs[tabProps.name]),
+			onClick: this.activateTab.bind(this, this.functionalTabs.get(tabProps.name)),
+			onDestroy: this.destroyTab.bind(this, tabProps.name, this.functionalTabs.get(tabProps.name)),
 			webview: new WebView({
 				$root: this.$webviewsContainer,
-				index: this.functionalTabs[tabProps.name],
+				index: this.functionalTabs.get(tabProps.name),
 				tabIndex,
 				url: tabProps.url,
 				role: 'function',
 				name: tabProps.name,
 				isActive: () => {
-					return this.functionalTabs[tabProps.name] === this.activeTabIndex;
+					return this.functionalTabs.get(tabProps.name) === this.activeTabIndex;
 				},
-				switchLoading: (loading: AnyObject, url: string) => {
-					if (!loading && this.loading[url]) {
-						this.loading[url] = false;
-					} else if (loading && !this.loading[url]) {
-						this.loading[url] = true;
+				switchLoading: (loading: boolean, url: string) => {
+					if (loading) {
+						this.loading.add(url);
+					} else {
+						this.loading.delete(url);
 					}
-					this.showLoading(this.loading[this.tabs[this.activeTabIndex].webview.props.url]);
+
+					this.showLoading(this.loading.has(this.tabs[this.activeTabIndex].webview.props.url));
 				},
 				onNetworkError: (index: number) => this.openNetworkTroubleshooting(index),
 				onTitleChange: this.updateBadge.bind(this),
@@ -549,17 +553,17 @@ class ServerManagerView {
 		// closed when the functional tab DOM is ready, handled in webview.js
 		this.$webviewsContainer.classList.remove('loaded');
 
-		this.activateTab(this.functionalTabs[tabProps.name]);
+		this.activateTab(this.functionalTabs.get(tabProps.name));
 	}
 
-	openSettings(nav = 'General'): void {
+	async openSettings(nav = 'General'): Promise<void> {
 		this.openFunctionalTab({
 			name: 'Settings',
 			materialIcon: 'settings',
 			url: `file://${rendererDirectory}/preference.html#${nav}`
 		});
 		this.$settingsButton.classList.add('active');
-		this.tabs[this.functionalTabs.Settings].webview.send('switch-settings-nav', nav);
+		await this.tabs[this.functionalTabs.get('Settings')].webview.send('switch-settings-nav', nav);
 	}
 
 	openAbout(): void {
@@ -584,7 +588,7 @@ class ServerManagerView {
 		ipcRenderer.send('save-last-tab', index);
 	}
 
-	// returns this.tabs in an way that does
+	// Returns this.tabs in an way that does
 	// not crash app when this.tabs is passed into
 	// ipcRenderer. Something about webview, and props.webview
 	// properties in ServerTab causes the app to crash.
@@ -594,7 +598,7 @@ class ServerManagerView {
 			const proto = Object.create(Object.getPrototypeOf(tab));
 			const tabClone = Object.assign(proto, tab);
 
-			tabClone.webview = { props: {} };
+			tabClone.webview = {props: {}};
 			tabClone.webview.props.name = tab.webview.props.name;
 			delete tabClone.props.webview;
 			tabs.push(tabClone);
@@ -611,24 +615,27 @@ class ServerManagerView {
 		if (this.activeTabIndex !== -1) {
 			if (this.activeTabIndex === index) {
 				return;
-			} else if (hideOldTab) {
+			}
+
+			if (hideOldTab) {
 				// If old tab is functional tab Settings, remove focus from the settings icon at sidebar bottom
 				if (this.tabs[this.activeTabIndex].props.role === 'function' && this.tabs[this.activeTabIndex].props.name === 'Settings') {
 					this.$settingsButton.classList.remove('active');
 				}
+
 				this.tabs[this.activeTabIndex].deactivate();
 			}
 		}
 
 		try {
 			this.tabs[index].webview.canGoBackButton();
-		} catch (err) {
+		} catch (_) {
 		}
 
 		this.activeTabIndex = index;
 		this.tabs[index].activate();
 
-		this.showLoading(this.loading[this.tabs[this.activeTabIndex].webview.props.url]);
+		this.showLoading(this.loading.has(this.tabs[this.activeTabIndex].webview.props.url));
 
 		ipcRenderer.send('update-menu', {
 			// JSON stringify this.tabs to avoid a crash
@@ -658,7 +665,7 @@ class ServerManagerView {
 		this.tabs[index].destroy();
 
 		delete this.tabs[index];
-		delete this.functionalTabs[name];
+		this.functionalTabs.delete(name);
 
 		// Issue #188: If the functional tab was not focused, do not activate another tab.
 		if (this.activeTabIndex === index) {
@@ -673,21 +680,21 @@ class ServerManagerView {
 		// Clear global variables
 		this.activeTabIndex = -1;
 		this.tabs = [];
-		this.functionalTabs = {};
+		this.functionalTabs.clear();
 
 		// Clear DOM elements
 		this.$tabsContainer.innerHTML = '';
 		this.$webviewsContainer.innerHTML = '';
 	}
 
-	reloadView(): void {
+	async reloadView(): Promise<void> {
 		// Save and remember the index of last active tab so that we can use it later
 		const lastActiveTab = this.tabs[this.activeTabIndex].props.index;
 		ConfigUtil.setConfigItem('lastActiveTab', lastActiveTab);
 
 		// Destroy the current view and re-initiate it
 		this.destroyView();
-		this.initTabs();
+		await this.initTabs();
 		this.initServerActions();
 	}
 
@@ -710,11 +717,9 @@ class ServerManagerView {
 		ipcRenderer.send('update-badge', messageCountAll);
 	}
 
-	updateGeneralSettings(setting: string, value: any): void {
-		const selector = 'webview:not([class*=disabled])';
-		const webview: Electron.WebviewTag = document.querySelector(selector);
-		if (webview) {
-			const webContents = webview.getWebContents();
+	updateGeneralSettings(setting: string, value: unknown): void {
+		if (this.getActiveWebview()) {
+			const webContents = this.getActiveWebview().getWebContents();
 			webContents.send(setting, value);
 		}
 	}
@@ -738,35 +743,40 @@ class ServerManagerView {
 		return !(url.endsWith('/login/') || this.tabs[tabIndex].webview.loading);
 	}
 
+	getActiveWebview(): Electron.WebviewTag {
+		const selector = 'webview:not(.disabled)';
+		const webview: Electron.WebviewTag = document.querySelector(selector);
+		return webview;
+	}
+
 	addContextMenu($serverImg: HTMLImageElement, index: number): void {
-		$serverImg.addEventListener('contextmenu', e => {
-			e.preventDefault();
+		$serverImg.addEventListener('contextmenu', event => {
+			event.preventDefault();
 			const template = [
 				{
 					label: 'Disconnect organization',
-					click: () => {
-						dialog.showMessageBox({
+					click: async () => {
+						const {response} = await dialog.showMessageBox({
 							type: 'warning',
 							buttons: ['YES', 'NO'],
 							defaultId: 0,
 							message: 'Are you sure you want to disconnect this organization?'
-						}, response => {
-							if (response === 0) {
-								if (DomainUtil.removeDomain(index)) {
-									ipcRenderer.send('reload-full-app');
-								} else {
-									const { title, content } = Messages.orgRemovalError(DomainUtil.getDomain(index).url);
-									dialog.showErrorBox(title, content);
-								}
-							}
 						});
+						if (response === 0) {
+							if (DomainUtil.removeDomain(index)) {
+								ipcRenderer.send('reload-full-app');
+							} else {
+								const {title, content} = Messages.orgRemovalError(DomainUtil.getDomain(index).url);
+								dialog.showErrorBox(title, content);
+							}
+						}
 					}
 				},
 				{
 					label: 'Notification settings',
 					enabled: this.isLoggedIn(index),
 					click: () => {
-						// switch to tab whose icon was right-clicked
+						// Switch to tab whose icon was right-clicked
 						this.activateTab(index);
 						this.tabs[index].webview.showNotificationSettings();
 					}
@@ -779,47 +789,85 @@ class ServerManagerView {
 				}
 			];
 			const contextMenu = Menu.buildFromTemplate(template);
-			contextMenu.popup({ window: remote.getCurrentWindow() });
+			contextMenu.popup({window: remote.getCurrentWindow()});
 		});
 	}
 
 	registerIpcs(): void {
-		const webviewListeners: AnyObject = {
-			'webview-reload': 'reload',
-			back: 'back',
-			focus: 'focus',
-			forward: 'forward',
-			zoomIn: 'zoomIn',
-			zoomOut: 'zoomOut',
-			zoomActualSize: 'zoomActualSize',
-			'log-out': 'logOut',
-			shortcut: 'showShortcut',
-			'tab-devtools': 'openDevTools'
-		};
+		const webviewListeners: Array<[string, (webview: WebView) => void]> = [
+			['webview-reload', webview => webview.reload()],
+			['back', webview => webview.back()],
+			['focus', webview => webview.focus()],
+			['forward', webview => webview.forward()],
+			['zoomIn', webview => webview.zoomIn()],
+			['zoomOut', webview => webview.zoomOut()],
+			['zoomActualSize', webview => webview.zoomActualSize()],
+			['log-out', webview => webview.logOut()],
+			['shortcut', webview => webview.showShortcut()],
+			['tab-devtools', webview => webview.openDevTools()]
+		];
 
-		for (const key in webviewListeners) {
-			ipcRenderer.on(key, () => {
+		for (const [channel, listener] of webviewListeners) {
+			ipcRenderer.on(channel, () => {
 				const activeWebview = this.tabs[this.activeTabIndex].webview;
 				if (activeWebview) {
-					activeWebview[webviewListeners[key] as string]();
+					listener(activeWebview);
 				}
 			});
 		}
 
+		ipcRenderer.on('certificate-error', (
+			event: Event,
+			webContentsId: number | null,
+			rendererCallbackId: number
+		) => {
+			const ignore = webContentsId !== null &&
+				this.tabs.some(
+					({webview}) =>
+						!webview.loading &&
+						webview.$el.getWebContentsId() === webContentsId &&
+						webview.props.ignoreCerts
+				);
+			ipcRenderer.send('renderer-callback', rendererCallbackId, ignore);
+		});
+
+		ipcRenderer.on('permission-request', (
+			event: Event,
+			{webContentsId, origin, permission}: {
+				webContentsId: number | null;
+				origin: string;
+				permission: string;
+			},
+			rendererCallbackId: number
+		) => {
+			const grant = webContentsId === null ?
+				origin === 'null' && permission === 'notifications' :
+				this.tabs.some(
+					({webview}) =>
+						!webview.loading &&
+						webview.$el.getWebContentsId() === webContentsId &&
+					webview.props.hasPermission?.(origin, permission)
+				);
+			console.log(
+				grant ? 'Granted' : 'Denied', 'permissions request for',
+				permission, 'from', origin
+			);
+			ipcRenderer.send('renderer-callback', rendererCallbackId, grant);
+		});
+
 		ipcRenderer.on('show-network-error', (event: Event, index: number) => {
 			this.openNetworkTroubleshooting(index);
 		});
 
-		ipcRenderer.on('open-settings', (event: Event, settingNav: string) => {
-			this.openSettings(settingNav);
+		ipcRenderer.on('open-settings', async (event: Event, settingNav: string) => {
+			await this.openSettings(settingNav);
 		});
 
 		ipcRenderer.on('open-about', this.openAbout.bind(this));
 
-		ipcRenderer.on('open-help', () => {
+		ipcRenderer.on('open-help', async () => {
 			// Open help page of current active server
-			const helpPage = this.getCurrentActiveServer() + '/help';
-			shell.openExternal(helpPage);
+			await LinkUtil.openBrowser(new URL('https://zulipchat.com/help/'));
 		});
 
 		ipcRenderer.on('reload-viewer', this.reloadView.bind(this, this.tabs[this.activeTabIndex].props.index));
@@ -838,17 +886,19 @@ class ServerManagerView {
 			this.activateLastTab(index);
 		});
 
-		ipcRenderer.on('open-org-tab', () => {
-			this.openSettings('AddServer');
+		ipcRenderer.on('open-org-tab', async () => {
+			await this.openSettings('AddServer');
 		});
 
-		ipcRenderer.on('reload-proxy', (event: Event, showAlert: boolean) => {
-			this.loadProxy().then(() => {
-				if (showAlert) {
-					alert('Proxy settings saved!');
-					ipcRenderer.send('reload-full-app');
-				}
-			});
+		ipcRenderer.on('reload-proxy', async (event: Event, showAlert: boolean) => {
+			await this.loadProxy();
+			if (showAlert) {
+				await dialog.showMessageBox({
+					message: 'Proxy settings saved!',
+					buttons: ['OK']
+				});
+				ipcRenderer.send('reload-full-app');
+			}
 		});
 
 		ipcRenderer.on('toggle-sidebar', (event: Event, show: boolean) => {
@@ -864,8 +914,8 @@ class ServerManagerView {
 			webviews.forEach(webview => {
 				try {
 					webview.setAudioMuted(state);
-				} catch (err) {
-					// webview is not ready yet
+				} catch (_) {
+					// Webview is not ready yet
 					webview.addEventListener('dom-ready', () => {
 						webview.setAudioMuted(state);
 					});
@@ -881,31 +931,28 @@ class ServerManagerView {
 				});
 				return;
 			}
+
 			this.updateGeneralSettings('toggle-menubar-setting', autoHideMenubar);
 		});
 
-		ipcRenderer.on('toggle-dnd', (event: Event, state: boolean, newSettings: SettingsOptions) => {
+		ipcRenderer.on('toggle-dnd', (event: Event, state: boolean, newSettings: DNDSettings) => {
 			this.toggleDNDButton(state);
 			ipcRenderer.send('forward-message', 'toggle-silent', newSettings.silent);
-			const selector = 'webview:not([class*=disabled])';
-			const webview: Electron.WebviewTag = document.querySelector(selector);
-			const webContents = webview.getWebContents();
+			const webContents = this.getActiveWebview().getWebContents();
 			webContents.send('toggle-dnd', state, newSettings);
 		});
 
 		ipcRenderer.on('update-realm-name', (event: Event, serverURL: string, realmName: string) => {
-			// TODO: TypeScript - Type annotate getDomains() or this domain paramter.
-			DomainUtil.getDomains().forEach((domain: any, index: number) => {
+			DomainUtil.getDomains().forEach((domain: DomainUtil.ServerConf, index: number) => {
 				if (domain.url.includes(serverURL)) {
-					const serverTooltipSelector = `.tab .server-tooltip`;
+					const serverTooltipSelector = '.tab .server-tooltip';
 					const serverTooltips = document.querySelectorAll(serverTooltipSelector);
 					serverTooltips[index].innerHTML = escape(realmName);
 					this.tabs[index].props.name = escape(realmName);
 					this.tabs[index].webview.props.name = realmName;
 
 					domain.alias = escape(realmName);
-					DomainUtil.db.push(`/domains[${index}]`, domain, true);
-					DomainUtil.reloadDB();
+					DomainUtil.updateDomain(index, domain);
 					// Update the realm name also on the Window menu
 					ipcRenderer.send('update-menu', {
 						tabs: this.tabsForIpc,
@@ -916,18 +963,17 @@ class ServerManagerView {
 		});
 
 		ipcRenderer.on('update-realm-icon', (event: Event, serverURL: string, iconURL: string) => {
-			// TODO: TypeScript - Type annotate getDomains() or this domain paramter.
-			DomainUtil.getDomains().forEach((domain: any, index: number) => {
+			DomainUtil.getDomains().forEach(async (domain, index) => {
 				if (domain.url.includes(serverURL)) {
-					DomainUtil.saveServerIcon(iconURL).then((localIconUrl: string) => {
-						const serverImgsSelector = `.tab .server-icons`;
-						const serverImgs: NodeListOf<HTMLImageElement> = document.querySelectorAll(serverImgsSelector);
-						serverImgs[index].src = localIconUrl;
-
-						domain.icon = localIconUrl;
-						DomainUtil.db.push(`/domains[${index}]`, domain, true);
-						DomainUtil.reloadDB();
+					const localIconUrl: string = await DomainUtil.saveServerIcon({
+						url: serverURL,
+						icon: iconURL
 					});
+					const serverImgsSelector = '.tab .server-icons';
+					const serverImgs: NodeListOf<HTMLImageElement> = document.querySelectorAll(serverImgsSelector);
+					serverImgs[index].src = localIconUrl;
+					domain.icon = localIconUrl;
+					DomainUtil.updateDomain(index, domain);
 				}
 			});
 		});
@@ -977,8 +1023,10 @@ class ServerManagerView {
 					ctx.font = '85px Helvetica';
 					ctx.fillText(String(Math.min(99, messageCount)), 64, 90);
 				}
+
 				return canvas;
 			}
+
 			ipcRenderer.send('update-taskbar-icon', createOverlayIcon(messageCount).toDataURL(), String(messageCount));
 		});
 
@@ -990,41 +1038,46 @@ class ServerManagerView {
 			clipboard.writeText(this.getCurrentActiveServer());
 		});
 
-		ipcRenderer.on('new-server', () => {
-			this.openSettings('AddServer');
+		ipcRenderer.on('new-server', async () => {
+			await this.openSettings('AddServer');
 		});
 
-		ipcRenderer.on('set-active', () => {
+		// Redo and undo functionality since the default API doesn't work on macOS
+		ipcRenderer.on('undo', () => {
+			return this.getActiveWebview().undo();
+		});
+
+		ipcRenderer.on('redo', () => {
+			return this.getActiveWebview().redo();
+		});
+
+		ipcRenderer.on('set-active', async () => {
 			const webviews: NodeListOf<Electron.WebviewTag> = document.querySelectorAll('webview');
-			webviews.forEach(webview => {
-				webview.send('set-active');
-			});
+			await Promise.all([...webviews].map(async webview => webview.send('set-active')));
 		});
 
-		ipcRenderer.on('set-idle', () => {
+		ipcRenderer.on('set-idle', async () => {
 			const webviews: NodeListOf<Electron.WebviewTag> = document.querySelectorAll('webview');
-			webviews.forEach(webview => {
-				webview.send('set-idle');
-			});
+			await Promise.all([...webviews].map(async webview => webview.send('set-idle')));
 		});
 
-		ipcRenderer.on('open-network-settings', () => {
-			this.openSettings('Network');
+		ipcRenderer.on('open-network-settings', async () => {
+			await this.openSettings('Network');
 		});
 	}
 }
 
-window.addEventListener('load', () => {
-	const serverManagerView = new ServerManagerView();
-	serverManagerView.init();
-	// only start electron-connect (auto reload on change) when its ran
+window.addEventListener('load', async () => {
+	// Only start electron-connect (auto reload on change) when its ran
 	// from `npm run dev` or `gulp dev` and not from `npm start` when
 	// app is started `npm start` main process's proces.argv will have
 	// `--no-electron-connect`
-	const mainProcessArgv = remote.getGlobal('process').argv;
-	if (isDev && !mainProcessArgv.includes('--no-electron-connect')) {
+	if (isDev && !remote.getGlobal('process').argv.includes('--no-electron-connect')) {
 		require('electron-connect').client.create();
 	}
+
+	const serverManagerView = new ServerManagerView();
+	await serverManagerView.init();
 });
 
-export = new ServerManagerView();
+export {};

app/renderer/js/notification/darwin-notifications.ts

@@ -1,34 +1,31 @@
-'use strict';
-import { ipcRenderer } from 'electron';
+import {ipcRenderer} from 'electron';
 import {
-	appId, customReply, focusCurrentServer, parseReply, setupReply
+	appId, customReply, focusCurrentServer, parseReply
 } from './helpers';
 
-import url = require('url');
-import MacNotifier = require('node-mac-notifier');
-import ConfigUtil = require('../utils/config-util');
+import MacNotifier from 'node-mac-notifier';
+import * as ConfigUtil from '../utils/config-util';
+import electron_bridge from '../electron-bridge';
 
 type ReplyHandler = (response: string) => void;
 type ClickHandler = () => void;
 let replyHandler: ReplyHandler;
 let clickHandler: ClickHandler;
 
-declare const window: ZulipWebWindow;
 interface NotificationHandlerArgs {
 	response: string;
 }
 
 class DarwinNotification {
-	tag: string;
+	tag: number;
 
-	constructor(title: string, opts: NotificationOptions) {
+	constructor(title: string, options: NotificationOptions) {
 		const silent: boolean = ConfigUtil.getConfigItem('silent') || false;
-		const { host, protocol } = location;
-		const { icon } = opts;
-		const profilePic = url.resolve(`${protocol}//${host}`, icon);
+		const {icon} = options;
+		const profilePic = new URL(icon, location.href).href;
 
-		this.tag = opts.tag;
-		const notification = new MacNotifier(title, Object.assign(opts, {
+		this.tag = Number.parseInt(options.tag, 10);
+		const notification = new MacNotifier(title, Object.assign(options, {
 			bundleId: appId,
 			canReply: true,
 			silent,
@@ -36,7 +33,7 @@ class DarwinNotification {
 		}));
 
 		notification.addEventListener('click', () => {
-			// focus to the server who sent the
+			// Focus to the server who sent the
 			// notification if not focused already
 			if (clickHandler) {
 				clickHandler();
@@ -58,23 +55,23 @@ class DarwinNotification {
 		return ConfigUtil.getConfigItem('showNotification') ? 'granted' : 'denied';
 	}
 
-	set onreply(handler: ReplyHandler) {
-		replyHandler = handler;
-	}
-
 	get onreply(): ReplyHandler {
 		return replyHandler;
 	}
 
-	set onclick(handler: ClickHandler) {
-		clickHandler = handler;
+	set onreply(handler: ReplyHandler) {
+		replyHandler = handler;
 	}
 
 	get onclick(): ClickHandler {
 		return clickHandler;
 	}
 
-	// not something that is common or
+	set onclick(handler: ClickHandler) {
+		clickHandler = handler;
+	}
+
+	// Not something that is common or
 	// used by zulip server but added to be
 	// future proff.
 	addEventListener(event: string, handler: ClickHandler | ReplyHandler): void {
@@ -87,15 +84,15 @@ class DarwinNotification {
 		}
 	}
 
-	notificationHandler({ response }: NotificationHandlerArgs): void {
-		response = parseReply(response);
+	async notificationHandler({response}: NotificationHandlerArgs): Promise<void> {
+		response = await parseReply(response);
 		focusCurrentServer();
-		if (window.electron_bridge.send_notification_reply_message_supported) {
-			window.electron_bridge.send_event('send_notification_reply_message', this.tag, response);
+		if (electron_bridge.send_notification_reply_message_supported) {
+			electron_bridge.send_event('send_notification_reply_message', this.tag, response);
 			return;
 		}
 
-		setupReply(this.tag);
+		electron_bridge.emit('narrow-by-topic', this.tag);
 		if (replyHandler) {
 			replyHandler(response);
 			return;
@@ -104,7 +101,7 @@ class DarwinNotification {
 		customReply(response);
 	}
 
-	// method specific to notification api
+	// Method specific to notification api
 	// used by zulip
 	close(): void {
 		return; // eslint-disable-line no-useless-return

app/renderer/js/notification/default-notification.ts

@@ -1,26 +1,24 @@
-'use strict';
+import {ipcRenderer} from 'electron';
+import {focusCurrentServer} from './helpers';
 
-import { ipcRenderer } from 'electron';
-import { focusCurrentServer } from './helpers';
-
-import ConfigUtil = require('../utils/config-util');
+import * as ConfigUtil from '../utils/config-util';
 
 const NativeNotification = window.Notification;
-class BaseNotification extends NativeNotification {
-	constructor(title: string, opts: NotificationOptions) {
-		opts.silent = true;
-		super(title, opts);
+export default class BaseNotification extends NativeNotification {
+	constructor(title: string, options: NotificationOptions) {
+		options.silent = true;
+		super(title, options);
 
 		this.addEventListener('click', () => {
-			// focus to the server who sent the
+			// Focus to the server who sent the
 			// notification if not focused already
 			focusCurrentServer();
 			ipcRenderer.send('focus-app');
 		});
 	}
 
-	static requestPermission(): void {
-		return; // eslint-disable-line no-useless-return
+	static async requestPermission(): Promise<NotificationPermission> {
+		return this.permission;
 	}
 
 	// Override default Notification permission
@@ -28,5 +26,3 @@ class BaseNotification extends NativeNotification {
 		return ConfigUtil.getConfigItem('showNotification') ? 'granted' : 'denied';
 	}
 }
-
-export = BaseNotification;

app/renderer/js/notification/helpers.ts

@@ -1,6 +1,6 @@
-import { remote } from 'electron';
+import {remote} from 'electron';
 
-import Logger = require('../utils/logger-util');
+import Logger from '../utils/logger-util';
 
 const logger = new Logger({
 	file: 'errors.log',
@@ -14,37 +14,28 @@ export type BotListItem = [string, string];
 const botsList: BotListItem[] = [];
 let botsListLoaded = false;
 
-// this function load list of bots from the server
-// sync=True for a synchronous getJSON request
+// This function load list of bots from the server
 // in case botsList isn't already completely loaded when required in parseRely
-export function loadBots(sync = false): void {
-	const { $ } = window;
+export async function loadBots(): Promise<void> {
 	botsList.length = 0;
-	if (sync) {
-		$.ajaxSetup({async: false});
-	}
-	$.getJSON('/json/users')
-		.done((data: any) => {
-			const { members } = data;
-			members.forEach((membersRow: any) => {
-				if (membersRow.is_bot) {
-					const bot = `@${membersRow.full_name}`;
-					const mention = `@**${bot.replace(/^@/, '')}**`;
-					botsList.push([bot, mention]);
-				}
-			});
-			botsListLoaded = true;
-		})
-		.fail((error: any) => {
-			logger.log('Load bots request failed: ', error.responseText);
-			logger.log('Load bots request status: ', error.statusText);
+	const response = await fetch('/json/users');
+	if (response.ok) {
+		const {members} = await response.json();
+		members.forEach(({is_bot, full_name}: {[key: string]: unknown}) => {
+			if (is_bot && typeof full_name === 'string') {
+				const bot = `@${full_name}`;
+				const mention = `@**${bot.replace(/^@/, '')}**`;
+				botsList.push([bot, mention]);
+			}
 		});
-	if (sync) {
-		$.ajaxSetup({async: true});
+		botsListLoaded = true;
+	} else {
+		logger.log('Load bots request failed: ', await response.text());
+		logger.log('Load bots request status: ', response.status);
 	}
 }
 
-export function checkElements(...elements: any[]): boolean {
+export function checkElements(...elements: unknown[]): boolean {
 	let status = true;
 	elements.forEach(element => {
 		if (element === null || element === undefined) {
@@ -55,14 +46,14 @@ export function checkElements(...elements: any[]): boolean {
 }
 
 export function customReply(reply: string): void {
-	// server does not support notification reply yet.
+	// Server does not support notification reply yet.
 	const buttonSelector = '.messagebox #send_controls button[type=submit]';
 	const messageboxSelector = '.selected_message .messagebox .messagebox-border .messagebox-content';
 	const textarea: HTMLInputElement = document.querySelector('#compose-textarea');
 	const messagebox: HTMLButtonElement = document.querySelector(messageboxSelector);
 	const sendButton: HTMLButtonElement = document.querySelector(buttonSelector);
 
-	// sanity check for old server versions
+	// Sanity check for old server versions
 	const elementsExists = checkElements(textarea, messagebox, sendButton);
 	if (!elementsExists) {
 		return;
@@ -77,19 +68,18 @@ const currentWindow = remote.getCurrentWindow();
 const webContents = remote.getCurrentWebContents();
 const webContentsId = webContents.id;
 
-// this function will focus the server that sent
+// This function will focus the server that sent
 // the notification. Main function implemented in main.js
 export function focusCurrentServer(): void {
-	// TODO: TypeScript: currentWindow of type BrowserWindow doesn't
-	// have a .send() property per typescript.
-	(currentWindow as any).send('focus-webview-with-id', webContentsId);
+	currentWindow.webContents.send('focus-webview-with-id', webContentsId);
 }
-// this function parses the reply from to notification
+
+// This function parses the reply from to notification
 // making it easier to reply from notification eg
 // @username in reply will be converted to @**username**
 // #stream in reply will be converted to #**stream**
 // bot mentions are not yet supported
-export function parseReply(reply: string): string {
+export async function parseReply(reply: string): Promise<string> {
 	const usersDiv = document.querySelectorAll('#user_presences li');
 	const streamHolder = document.querySelectorAll('#stream_filters li');
 
@@ -128,9 +118,9 @@ export function parseReply(reply: string): string {
 		reply = reply.replace(regex, streamMention);
 	});
 
-	// If botsList isn't completely loaded yet, make a synchronous getJSON request for list
-	if (botsListLoaded === false) {
-		loadBots(true);
+	// If botsList isn't completely loaded yet, make a request for list
+	if (!botsListLoaded) {
+		await loadBots();
 	}
 
 	// Iterate for every bot name and replace in reply
@@ -145,9 +135,3 @@ export function parseReply(reply: string): string {
 	reply = reply.replace(/\\n/, '\n');
 	return reply;
 }
-
-export function setupReply(id: string): void {
-	const { narrow } = window;
-	const narrowByTopic = narrow.by_topic || narrow.by_subject;
-	narrowByTopic(id, { trigger: 'notification' });
-}

app/renderer/js/notification/index.ts

@@ -1,25 +1,73 @@
-'use strict';
+import {remote} from 'electron';
+import electron_bridge from '../electron-bridge';
+import {appId, loadBots} from './helpers';
 
-import { remote } from 'electron';
-import * as params from '../utils/params-util';
-import { appId, loadBots } from './helpers';
-
-import DefaultNotification = require('./default-notification');
-const { app } = remote;
+import DefaultNotification from './default-notification';
+const {app} = remote;
 
 // From https://github.com/felixrieseberg/electron-windows-notifications#appusermodelid
 // On windows 8 we have to explicitly set the appUserModelId otherwise notification won't work.
 app.setAppUserModelId(appId);
 
-window.Notification = DefaultNotification;
+let Notification = DefaultNotification;
 
 if (process.platform === 'darwin') {
-	window.Notification = require('./darwin-notifications');
+	Notification = require('./darwin-notifications');
 }
 
-window.addEventListener('load', () => {
-	// eslint-disable-next-line no-undef, @typescript-eslint/camelcase
-	if (params.isPageParams() && page_params.realm_uri) {
-		loadBots();
+export interface NotificationData {
+	close: () => void;
+	title: string;
+	dir: NotificationDirection;
+	lang: string;
+	body: string;
+	tag: string;
+	image: string;
+	icon: string;
+	badge: string;
+	vibrate: readonly number[];
+	timestamp: number;
+	renotify: boolean;
+	silent: boolean;
+	requireInteraction: boolean;
+	data: unknown;
+	actions: readonly NotificationAction[];
+}
+
+export function newNotification(
+	title: string,
+	options: NotificationOptions | undefined,
+	dispatch: (type: string, eventInit: EventInit) => boolean
+): NotificationData {
+	const notification = new Notification(title, options);
+	for (const type of ['click', 'close', 'error', 'show']) {
+		notification.addEventListener(type, (ev: Event) => {
+			if (!dispatch(type, ev)) {
+				ev.preventDefault();
+			}
+		});
 	}
+
+	return {
+		close: () => notification.close(),
+		title: notification.title,
+		dir: notification.dir,
+		lang: notification.lang,
+		body: notification.body,
+		tag: notification.tag,
+		image: notification.image,
+		icon: notification.icon,
+		badge: notification.badge,
+		vibrate: notification.vibrate,
+		timestamp: notification.timestamp,
+		renotify: notification.renotify,
+		silent: notification.silent,
+		requireInteraction: notification.requireInteraction,
+		data: notification.data,
+		actions: notification.actions
+	};
+}
+
+electron_bridge.once('zulip-loaded', async () => {
+	await loadBots();
 });

app/renderer/js/pages/network.ts

@@ -1,16 +1,10 @@
-'use strict';
+import {ipcRenderer} from 'electron';
 
-import { ipcRenderer } from 'electron';
-
-class NetworkTroubleshootingView {
-	init($reconnectButton: Element, $settingsButton: Element): void {
-		$reconnectButton.addEventListener('click', () => {
-			ipcRenderer.send('forward-message', 'reload-viewer');
-		});
-		$settingsButton.addEventListener('click', () => {
-			ipcRenderer.send('forward-message', 'open-settings');
-		});
-	}
+export function init($reconnectButton: Element, $settingsButton: Element): void {
+	$reconnectButton.addEventListener('click', () => {
+		ipcRenderer.send('forward-message', 'reload-viewer');
+	});
+	$settingsButton.addEventListener('click', () => {
+		ipcRenderer.send('forward-message', 'open-settings');
+	});
 }
-
-export = new NetworkTroubleshootingView();

app/renderer/js/pages/preference/add-certificate.ts

@@ -1,23 +1,26 @@
 'use-strict';
 
-import { remote, OpenDialogOptions } from 'electron';
+import {remote, OpenDialogOptions} from 'electron';
 
-import path = require('path');
-import BaseComponent = require('../../components/base');
-import CertificateUtil = require('../../utils/certificate-util');
-import DomainUtil = require('../../utils/domain-util');
-import t = require('../../utils/translation-util');
+import path from 'path';
+import BaseComponent from '../../components/base';
+import * as CertificateUtil from '../../utils/certificate-util';
+import * as DomainUtil from '../../utils/domain-util';
+import * as t from '../../utils/translation-util';
 
-const { dialog } = remote;
+interface AddCertificateProps {
+	$root: Element;
+}
 
-class AddCertificate extends BaseComponent {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+const {dialog} = remote;
+
+export default class AddCertificate extends BaseComponent {
+	props: AddCertificateProps;
 	_certFile: string;
 	$addCertificate: Element | null;
 	addCertificateButton: Element | null;
 	serverUrl: HTMLInputElement | null;
-	constructor(props: any) {
+	constructor(props: AddCertificateProps) {
 		super();
 		this.props = props;
 		this._certFile = '';
@@ -46,7 +49,7 @@ class AddCertificate extends BaseComponent {
 		this.initListeners();
 	}
 
-	validateAndAdd(): void {
+	async validateAndAdd(): Promise<void> {
 		const certificate = this._certFile;
 		const serverUrl = this.serverUrl.value;
 		if (certificate !== '' && serverUrl !== '') {
@@ -56,45 +59,41 @@ class AddCertificate extends BaseComponent {
 			if (!copy) {
 				return;
 			}
+
 			CertificateUtil.setCertificate(server, fileName);
-			dialog.showMessageBox({
-				title: 'Success',
-				message: `Certificate saved!`
-			});
 			this.serverUrl.value = '';
+			await dialog.showMessageBox({
+				title: 'Success',
+				message: 'Certificate saved!'
+			});
 		} else {
 			dialog.showErrorBox('Error', `Please, ${serverUrl === '' ?
 				'Enter an Organization URL' : 'Choose certificate file'}`);
 		}
 	}
 
-	addHandler(): void {
+	async addHandler(): Promise<void> {
 		const showDialogOptions: OpenDialogOptions = {
 			title: 'Select file',
 			properties: ['openFile'],
-			filters: [{ name: 'crt, pem', extensions: ['crt', 'pem'] }]
+			filters: [{name: 'crt, pem', extensions: ['crt', 'pem']}]
 		};
-		dialog.showOpenDialog(showDialogOptions, selectedFile => {
-			if (selectedFile) {
-				this._certFile = selectedFile[0] || '';
-				this.validateAndAdd();
-			}
-		});
+		const {filePaths, canceled} = await dialog.showOpenDialog(showDialogOptions);
+		if (!canceled) {
+			this._certFile = filePaths[0] || '';
+			await this.validateAndAdd();
+		}
 	}
 
 	initListeners(): void {
-		this.addCertificateButton.addEventListener('click', () => {
-			this.addHandler();
+		this.addCertificateButton.addEventListener('click', async () => {
+			await this.addHandler();
 		});
 
-		this.serverUrl.addEventListener('keypress', event => {
-			const EnterkeyCode = event.keyCode;
-
-			if (EnterkeyCode === 13) {
-				this.addHandler();
+		this.serverUrl.addEventListener('keypress', async event => {
+			if (event.key === 'Enter') {
+				await this.addHandler();
 			}
 		});
 	}
 }
-
-export = AddCertificate;

app/renderer/js/pages/preference/badge-settings.ts

@@ -1,63 +1,44 @@
-'use strict';
-import { app } from 'electron';
+import electron, {app} from 'electron';
 
-import electron = require('electron');
-import ConfigUtil = require('../../utils/config-util');
+import * as ConfigUtil from '../../utils/config-util';
 
-let instance: BadgeSettings | any = null;
-
-class BadgeSettings {
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
-
-		return instance;
-	}
-
-	showBadgeCount(messageCount: number, mainWindow: electron.BrowserWindow): void {
-		if (process.platform === 'win32') {
-			this.updateOverlayIcon(messageCount, mainWindow);
-		} else {
-			// This should work on both macOS and Linux
-			app.setBadgeCount(messageCount);
-		}
-	}
-
-	hideBadgeCount(mainWindow: electron.BrowserWindow): void {
-		if (process.platform === 'darwin') {
-			app.setBadgeCount(0);
-		}
-		if (process.platform === 'win32') {
-			mainWindow.setOverlayIcon(null, '');
-		}
-	}
-
-	updateBadge(badgeCount: number, mainWindow: electron.BrowserWindow): void {
-		if (ConfigUtil.getConfigItem('badgeOption', true)) {
-			this.showBadgeCount(badgeCount, mainWindow);
-		} else {
-			this.hideBadgeCount(mainWindow);
-		}
-	}
-
-	updateOverlayIcon(messageCount: number, mainWindow: electron.BrowserWindow): void {
-		if (!mainWindow.isFocused()) {
-			mainWindow.flashFrame(ConfigUtil.getConfigItem('flashTaskbarOnMessage'));
-		}
-		if (messageCount === 0) {
-			mainWindow.setOverlayIcon(null, '');
-		} else {
-			mainWindow.webContents.send('render-taskbar-icon', messageCount);
-		}
-	}
-
-	updateTaskbarIcon(data: string, text: string, mainWindow: electron.BrowserWindow): void {
-		const img = electron.nativeImage.createFromDataURL(data);
-		mainWindow.setOverlayIcon(img, text);
+function showBadgeCount(messageCount: number, mainWindow: electron.BrowserWindow): void {
+	if (process.platform === 'win32') {
+		updateOverlayIcon(messageCount, mainWindow);
+	} else {
+		app.badgeCount = messageCount;
 	}
 }
 
-export = new BadgeSettings();
+function hideBadgeCount(mainWindow: electron.BrowserWindow): void {
+	if (process.platform === 'win32') {
+		mainWindow.setOverlayIcon(null, '');
+	} else {
+		app.badgeCount = 0;
+	}
+}
+
+export function updateBadge(badgeCount: number, mainWindow: electron.BrowserWindow): void {
+	if (ConfigUtil.getConfigItem('badgeOption', true)) {
+		showBadgeCount(badgeCount, mainWindow);
+	} else {
+		hideBadgeCount(mainWindow);
+	}
+}
+
+function updateOverlayIcon(messageCount: number, mainWindow: electron.BrowserWindow): void {
+	if (!mainWindow.isFocused()) {
+		mainWindow.flashFrame(ConfigUtil.getConfigItem('flashTaskbarOnMessage'));
+	}
+
+	if (messageCount === 0) {
+		mainWindow.setOverlayIcon(null, '');
+	} else {
+		mainWindow.webContents.send('render-taskbar-icon', messageCount);
+	}
+}
+
+export function updateTaskbarIcon(data: string, text: string, mainWindow: electron.BrowserWindow): void {
+	const img = electron.nativeImage.createFromDataURL(data);
+	mainWindow.setOverlayIcon(img, text);
+}

app/renderer/js/pages/preference/base-section.ts

@@ -1,12 +1,17 @@
-'use strict';
+import {ipcRenderer} from 'electron';
+import escape from 'escape-html';
 
-import { ipcRenderer } from 'electron';
+import BaseComponent from '../../components/base';
 
-import BaseComponent = require('../../components/base');
+interface BaseSectionProps {
+	$element: HTMLElement;
+	disabled?: boolean;
+	value: boolean;
+	clickHandler: () => void;
+}
 
-class BaseSection extends BaseComponent {
-	// TODO: TypeScript - Here props should be object type
-	generateSettingOption(props: any): void {
+export default class BaseSection extends BaseComponent {
+	generateSettingOption(props: BaseSectionProps): void {
 		const {$element, disabled, value, clickHandler} = props;
 
 		$element.innerHTML = '';
@@ -19,8 +24,8 @@ class BaseSection extends BaseComponent {
 		}
 	}
 
-	generateOptionTemplate(settingOption: boolean, disabled: boolean): string {
-		const label = disabled ? `<label class="disallowed" title="Setting locked by system administrator."/>` : `<label/>`;
+	generateOptionTemplate(settingOption: boolean, disabled?: boolean): string {
+		const label = disabled ? '<label class="disallowed" title="Setting locked by system administrator."/>' : '<label/>';
 		if (settingOption) {
 			return `
 				<div class="action">
@@ -30,8 +35,9 @@ class BaseSection extends BaseComponent {
 					</div>
 				</div>
 			`;
-		} else {
-			return `
+		}
+
+		return `
 				<div class="action">
 					<div class="switch">
 					  <input class="toggle toggle-round" type="checkbox">
@@ -39,12 +45,21 @@ class BaseSection extends BaseComponent {
 					</div>
 				</div>
 			`;
-		}
+	}
+
+	/* A method that in future can be used to create dropdown menus using <select> <option> tags.
+		it needs an object which has ``key: value`` pairs and will return a string that can be appended to HTML
+	*/
+	generateSelectTemplate(options: {[key: string]: string}, className?: string, idName?: string): string {
+		let select = `<select class="${escape(className)}" id="${escape(idName)}">\n`;
+		Object.keys(options).forEach(key => {
+			select += `<option name="${escape(key)}" value="${escape(key)}">${escape(options[key])}</option>\n`;
+		});
+		select += '</select>';
+		return select;
 	}
 
 	reloadApp(): void {
 		ipcRenderer.send('forward-message', 'reload-viewer');
 	}
 }
-
-export = BaseSection;

app/renderer/js/pages/preference/connected-org-section.ts

@@ -1,23 +1,24 @@
-'use strict';
+import {ipcRenderer} from 'electron';
 
-import { ipcRenderer } from 'electron';
+import BaseSection from './base-section';
+import * as DomainUtil from '../../utils/domain-util';
+import ServerInfoForm from './server-info-form';
+import AddCertificate from './add-certificate';
+import FindAccounts from './find-accounts';
+import * as t from '../../utils/translation-util';
 
-import BaseSection = require('./base-section');
-import DomainUtil = require('../../utils/domain-util');
-import ServerInfoForm = require('./server-info-form');
-import AddCertificate = require('./add-certificate');
-import FindAccounts = require('./find-accounts');
-import t = require('../../utils/translation-util');
+interface ConnectedOrgSectionProps {
+	$root: Element;
+}
 
-class ConnectedOrgSection extends BaseSection {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+export default class ConnectedOrgSection extends BaseSection {
+	props: ConnectedOrgSectionProps;
 	$serverInfoContainer: Element | null;
 	$existingServers: Element | null;
 	$newOrgButton: HTMLButtonElement | null;
 	$addCertificateContainer: Element | null;
 	$findAccountsContainer: Element | null;
-	constructor(props: any) {
+	constructor(props: ConnectedOrgSectionProps) {
 		super();
 		this.props = props;
 	}
@@ -57,10 +58,10 @@ class ConnectedOrgSection extends BaseSection {
 		// Show noServerText if no servers are there otherwise hide it
 		this.$existingServers.innerHTML = servers.length === 0 ? noServerText : '';
 
-		for (let i = 0; i < servers.length; i++) {
+		for (const [i, server] of servers.entries()) {
 			new ServerInfoForm({
 				$root: this.$serverInfoContainer,
-				server: servers[i],
+				server,
 				index: i,
 				onChange: this.reloadApp
 			}).init();
@@ -86,5 +87,3 @@ class ConnectedOrgSection extends BaseSection {
 		}).init();
 	}
 }
-
-export = ConnectedOrgSection;

app/renderer/js/pages/preference/find-accounts.ts

@@ -1,17 +1,19 @@
 'use-strict';
 
-import { shell } from 'electron';
+import BaseComponent from '../../components/base';
+import * as LinkUtil from '../../utils/link-util';
+import * as t from '../../utils/translation-util';
 
-import BaseComponent = require('../../components/base');
-import t = require('../../utils/translation-util');
+interface FindAccountsProps {
+	$root: Element;
+}
 
-class FindAccounts extends BaseComponent {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+export default class FindAccounts extends BaseComponent {
+	props: FindAccountsProps;
 	$findAccounts: Element | null;
 	$findAccountsButton: Element | null;
 	$serverUrlField: HTMLInputElement | null;
-	constructor(props: any) {
+	constructor(props: FindAccountsProps) {
 		super();
 		this.props = props;
 	}
@@ -38,19 +40,21 @@ class FindAccounts extends BaseComponent {
 		this.initListeners();
 	}
 
-	findAccounts(url: string): void {
+	async findAccounts(url: string): Promise<void> {
 		if (!url) {
 			return;
 		}
+
 		if (!url.startsWith('http')) {
 			url = 'https://' + url;
 		}
-		shell.openExternal(url + '/accounts/find');
+
+		await LinkUtil.openBrowser(new URL('/accounts/find', url));
 	}
 
 	initListeners(): void {
-		this.$findAccountsButton.addEventListener('click', () => {
-			this.findAccounts(this.$serverUrlField.value);
+		this.$findAccountsButton.addEventListener('click', async () => {
+			await this.findAccounts(this.$serverUrlField.value);
 		});
 
 		this.$serverUrlField.addEventListener('click', () => {
@@ -59,9 +63,9 @@ class FindAccounts extends BaseComponent {
 			}
 		});
 
-		this.$serverUrlField.addEventListener('keypress', event => {
-			if (event.keyCode === 13) {
-				this.findAccounts(this.$serverUrlField.value);
+		this.$serverUrlField.addEventListener('keypress', async event => {
+			if (event.key === 'Enter') {
+				await this.findAccounts(this.$serverUrlField.value);
 			}
 		});
 
@@ -74,5 +78,3 @@ class FindAccounts extends BaseComponent {
 		});
 	}
 }
-
-export = FindAccounts;

app/renderer/js/pages/preference/general-section.ts

@@ -1,21 +1,24 @@
-'use strict';
-import { ipcRenderer, remote, OpenDialogOptions } from 'electron';
+import {ipcRenderer, remote, OpenDialogOptions} from 'electron';
 
-import path = require('path');
-import fs = require('fs-extra');
+import path from 'path';
+import fs from 'fs-extra';
 
-const { app, dialog } = remote;
+const {app, dialog} = remote;
 const currentBrowserWindow = remote.getCurrentWindow();
 
-import BaseSection = require('./base-section');
-import ConfigUtil = require('../../utils/config-util');
-import EnterpriseUtil = require('./../../utils/enterprise-util');
-import t = require('../../utils/translation-util');
+import BaseSection from './base-section';
+import * as ConfigUtil from '../../utils/config-util';
+import * as EnterpriseUtil from '../../utils/enterprise-util';
+import * as t from '../../utils/translation-util';
+import supportedLocales from '../../../../translations/supported-locales.json';
 
-class GeneralSection extends BaseSection {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
-	constructor(props: any) {
+interface GeneralSectionProps {
+	$root: Element;
+}
+
+export default class GeneralSection extends BaseSection {
+	props: GeneralSectionProps;
+	constructor(props: GeneralSectionProps) {
 		super();
 		this.props = props;
 	}
@@ -93,29 +96,32 @@ class GeneralSection extends BaseSection {
 				</div>
 				<div class="title">${t.__('Advanced')}</div>
 				<div class="settings-card">
-				<div class="setting-row" id="enable-error-reporting">
-					<div class="setting-description">${t.__('Enable error reporting (requires restart)')}</div>
-					<div class="setting-control"></div>
-				</div>
-				<div class="setting-row" id="show-download-folder">
-					<div class="setting-description">${t.__('Show downloaded files in file manager')}</div>
-					<div class="setting-control"></div>
-				</div>
-				<div class="setting-row" id="add-custom-css">
-				<div class="setting-description">
-					${t.__('Add custom CSS')}
-				</div>
-				<button class="custom-css-button green">${t.__('Upload')}</button>
-			</div>
-			<div class="setting-row" id="remove-custom-css">
-				<div class="setting-description">
-					<div class="selected-css-path" id="custom-css-path">${ConfigUtil.getConfigItem('customCSS')}</div>
-				</div>
-				<div class="action red" id="css-delete-action">
-					<i class="material-icons">indeterminate_check_box</i>
-					<span>${t.__('Delete')}</span>
-				</div>
-			</div>
+
+					<div class="setting-row" id="enable-error-reporting">
+						<div class="setting-description">${t.__('Enable error reporting (requires restart)')}</div>
+						<div class="setting-control"></div>
+					</div>
+
+					<div class="setting-row" id="app-language">
+						<div class="setting-description">${t.__('App language (requires restart)')}</div>
+						<div  id="lang-div" class="lang-div"></div>
+					</div>
+
+					<div class="setting-row" id="add-custom-css">
+						<div class="setting-description">
+							${t.__('Add custom CSS')}
+						</div>
+						<button class="custom-css-button green">${t.__('Upload')}</button>
+					</div>
+					<div class="setting-row" id="remove-custom-css">
+						<div class="setting-description">
+							<div class="selected-css-path" id="custom-css-path">${ConfigUtil.getConfigString('customCSS', '')}</div>
+						</div>
+						<div class="action red" id="css-delete-action">
+							<i class="material-icons">indeterminate_check_box</i>
+							<span>${t.__('Delete')}</span>
+						</div>
+					</div>
 					<div class="setting-row" id="download-folder">
 						<div class="setting-description">
 							${t.__('Default download location')}
@@ -124,10 +130,13 @@ class GeneralSection extends BaseSection {
 					</div>
 					<div class="setting-row">
 						<div class="setting-description">
-							<div class="download-folder-path">${ConfigUtil.getConfigItem('downloadsPath', `${app.getPath('downloads')}`)}</div>
+							<div class="download-folder-path">${ConfigUtil.getConfigString('downloadsPath', app.getPath('downloads'))}</div>
 						</div>
 					</div>
-
+					<div class="setting-row" id="prompt-download">
+						<div class="setting-description">${t.__('Ask where to save files before downloading')}</div>
+						<div class="setting-control"></div>
+					</div>
 				</div>
 				<div class="title">${t.__('Reset Application Data')}</div>
                 <div class="settings-card">
@@ -137,7 +146,7 @@ class GeneralSection extends BaseSection {
 						<button class="reset-data-button red w-150">${t.__('Reset App Data')}</button>
 					</div>
 				</div>
-            </div>
+			</div>
 		`;
 	}
 
@@ -158,9 +167,10 @@ class GeneralSection extends BaseSection {
 		this.showCustomCSSPath();
 		this.removeCustomCSS();
 		this.downloadFolder();
-		this.showDownloadFolder();
 		this.updateQuitOnCloseOption();
+		this.updatePromptDownloadOption();
 		this.enableErrorReporting();
+		this.setLocale();
 
 		// Platform specific settings
 
@@ -168,6 +178,7 @@ class GeneralSection extends BaseSection {
 		if (process.platform === 'win32') {
 			this.updateFlashTaskbar();
 		}
+
 		// Dock bounce on macOS
 		if (process.platform === 'darwin') {
 			this.updateDockBouncing();
@@ -254,6 +265,7 @@ class GeneralSection extends BaseSection {
 					ConfigUtil.setConfigItem('betaUpdate', false);
 					this.betaUpdateOption();
 				}
+
 				this.autoUpdateOption();
 			}
 		});
@@ -281,9 +293,7 @@ class GeneralSection extends BaseSection {
 				const newValue = !ConfigUtil.getConfigItem('silent', true);
 				ConfigUtil.setConfigItem('silent', newValue);
 				this.updateSilentOption();
-				// TODO: TypeScript: currentWindow of type BrowserWindow doesn't
-				// have a .send() property per typescript.
-				(currentBrowserWindow as any).send('toggle-silent', newValue);
+				currentBrowserWindow.webContents.send('toggle-silent', newValue);
 			}
 		});
 	}
@@ -362,43 +372,59 @@ class GeneralSection extends BaseSection {
 		});
 	}
 
-	clearAppDataDialog(): void {
+	async clearAppDataDialog(): Promise<void> {
 		const clearAppDataMessage = 'By clicking proceed you will be removing all added accounts and preferences from Zulip. When the application restarts, it will be as if you are starting Zulip for the first time.';
-		const getAppPath = path.join(app.getPath('appData'), app.getName());
+		const getAppPath = path.join(app.getPath('appData'), app.name);
 
-		dialog.showMessageBox({
+		const {response} = await dialog.showMessageBox({
 			type: 'warning',
 			buttons: ['YES', 'NO'],
 			defaultId: 0,
 			message: 'Are you sure',
 			detail: clearAppDataMessage
-		}, response => {
-			if (response === 0) {
-				fs.remove(getAppPath);
-				setTimeout(() => ipcRenderer.send('forward-message', 'hard-reload'), 1000);
-			}
 		});
+		if (response === 0) {
+			await fs.remove(getAppPath);
+			ipcRenderer.send('forward-message', 'hard-reload');
+		}
 	}
 
-	customCssDialog(): void {
+	async customCssDialog(): Promise<void> {
 		const showDialogOptions: OpenDialogOptions = {
 			title: 'Select file',
 			properties: ['openFile'],
-			filters: [{ name: 'CSS file', extensions: ['css'] }]
+			filters: [{name: 'CSS file', extensions: ['css']}]
 		};
 
-		dialog.showOpenDialog(showDialogOptions, selectedFile => {
-			if (selectedFile) {
-				ConfigUtil.setConfigItem('customCSS', selectedFile[0]);
-				ipcRenderer.send('forward-message', 'hard-reload');
-			}
-		});
+		const {filePaths, canceled} = await dialog.showOpenDialog(showDialogOptions);
+		if (!canceled) {
+			ConfigUtil.setConfigItem('customCSS', filePaths[0]);
+			ipcRenderer.send('forward-message', 'hard-reload');
+		}
 	}
 
 	updateResetDataOption(): void {
 		const resetDataButton = document.querySelector('#resetdata-option .reset-data-button');
-		resetDataButton.addEventListener('click', () => {
-			this.clearAppDataDialog();
+		resetDataButton.addEventListener('click', async () => {
+			await this.clearAppDataDialog();
+		});
+	}
+
+	setLocale(): void {
+		const langDiv: HTMLSelectElement = document.querySelector('.lang-div');
+		// This path is for the JSON file that stores key: value pairs for supported locales
+		const langList = this.generateSelectTemplate(supportedLocales, 'lang-menu');
+		langDiv.innerHTML += langList;
+		// `langMenu` is the select-option dropdown menu formed after executing the previous command
+		const langMenu: HTMLSelectElement = document.querySelector('.lang-menu');
+
+		// The next three lines set the selected language visible on the dropdown button
+		let language = ConfigUtil.getConfigItem('appLanguage');
+		language = language && langMenu.options.namedItem(language) ? language : 'en-US';
+		langMenu.options.namedItem(language).selected = true;
+
+		langMenu.addEventListener('change', (event: Event) => {
+			ConfigUtil.setConfigItem('appLanguage', (event.target as HTMLSelectElement).value);
 		});
 	}
 
@@ -416,8 +442,8 @@ class GeneralSection extends BaseSection {
 
 	addCustomCSS(): void {
 		const customCSSButton = document.querySelector('#add-custom-css .custom-css-button');
-		customCSSButton.addEventListener('click', () => {
-			this.customCssDialog();
+		customCSSButton.addEventListener('click', async () => {
+			await this.customCssDialog();
 		});
 	}
 
@@ -431,43 +457,41 @@ class GeneralSection extends BaseSection {
 	removeCustomCSS(): void {
 		const removeCSSButton = document.querySelector('#css-delete-action');
 		removeCSSButton.addEventListener('click', () => {
-			ConfigUtil.setConfigItem('customCSS', "");
+			ConfigUtil.setConfigItem('customCSS', '');
 			ipcRenderer.send('forward-message', 'hard-reload');
 		});
 	}
 
-	downloadFolderDialog(): void {
+	async downloadFolderDialog(): Promise<void> {
 		const showDialogOptions: OpenDialogOptions = {
 			title: 'Select Download Location',
 			properties: ['openDirectory']
 		};
 
-		dialog.showOpenDialog(showDialogOptions, selectedFolder => {
-			if (selectedFolder) {
-				ConfigUtil.setConfigItem('downloadsPath', selectedFolder[0]);
-				const downloadFolderPath: HTMLElement = document.querySelector('.download-folder-path');
-				downloadFolderPath.innerText = selectedFolder[0];
-			}
-		});
+		const {filePaths, canceled} = await dialog.showOpenDialog(showDialogOptions);
+		if (!canceled) {
+			ConfigUtil.setConfigItem('downloadsPath', filePaths[0]);
+			const downloadFolderPath: HTMLElement = document.querySelector('.download-folder-path');
+			downloadFolderPath.textContent = filePaths[0];
+		}
 	}
+
 	downloadFolder(): void {
 		const downloadFolder = document.querySelector('#download-folder .download-folder-button');
-		downloadFolder.addEventListener('click', () => {
-			this.downloadFolderDialog();
+		downloadFolder.addEventListener('click', async () => {
+			await this.downloadFolderDialog();
 		});
 	}
 
-	showDownloadFolder(): void {
+	updatePromptDownloadOption(): void {
 		this.generateSettingOption({
-			$element: document.querySelector('#show-download-folder .setting-control'),
-			value: ConfigUtil.getConfigItem('showDownloadFolder', false),
+			$element: document.querySelector('#prompt-download .setting-control'),
+			value: ConfigUtil.getConfigItem('promptDownload', false),
 			clickHandler: () => {
-				const newValue = !ConfigUtil.getConfigItem('showDownloadFolder');
-				ConfigUtil.setConfigItem('showDownloadFolder', newValue);
-				this.showDownloadFolder();
+				const newValue = !ConfigUtil.getConfigItem('promptDownload');
+				ConfigUtil.setConfigItem('promptDownload', newValue);
+				this.updatePromptDownloadOption();
 			}
 		});
 	}
 }
-
-export = GeneralSection;

app/renderer/js/pages/preference/nav.ts

@@ -1,14 +1,16 @@
-'use strict';
+import BaseComponent from '../../components/base';
+import * as t from '../../utils/translation-util';
 
-import BaseComponent = require('../../components/base');
-import t = require('../../utils/translation-util');
+interface PreferenceNavProps {
+	$root: Element;
+	onItemSelected: (navItem: string) => void;
+}
 
-class PreferenceNav extends BaseComponent {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+export default class PreferenceNav extends BaseComponent {
+	props: PreferenceNavProps;
 	navItems: string[];
 	$el: Element;
-	constructor(props: any) {
+	constructor(props: PreferenceNavProps) {
 		super();
 		this.props = props;
 		this.navItems = ['General', 'Network', 'AddServer', 'Organizations', 'Shortcuts'];
@@ -64,5 +66,3 @@ class PreferenceNav extends BaseComponent {
 		$item.classList.remove('active');
 	}
 }
-
-export = PreferenceNav;

app/renderer/js/pages/preference/network-section.ts

@@ -1,20 +1,21 @@
-'use strict';
+import {ipcRenderer} from 'electron';
 
-import { ipcRenderer } from 'electron';
+import BaseSection from './base-section';
+import * as ConfigUtil from '../../utils/config-util';
+import * as t from '../../utils/translation-util';
 
-import BaseSection = require('./base-section');
-import ConfigUtil = require('../../utils/config-util');
-import t = require('../../utils/translation-util');
+interface NetworkSectionProps {
+	$root: Element;
+}
 
-class NetworkSection extends BaseSection {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+export default class NetworkSection extends BaseSection {
+	props: NetworkSectionProps;
 	$proxyPAC: HTMLInputElement;
 	$proxyRules: HTMLInputElement;
 	$proxyBypass: HTMLInputElement;
 	$proxySaveAction: Element;
 	$manualProxyBlock: Element;
-	constructor(props: any) {
+	constructor(props: NetworkSectionProps) {
 		super();
 		this.props = props;
 	}
@@ -104,11 +105,13 @@ class NetworkSection extends BaseSection {
 					ConfigUtil.setConfigItem('useManualProxy', !manualProxyValue);
 					this.toggleManualProxySettings(!manualProxyValue);
 				}
-				if (newValue === false) {
+
+				if (!newValue) {
 					// Remove proxy system proxy settings
 					ConfigUtil.setConfigItem('proxyRules', '');
 					ipcRenderer.send('forward-message', 'reload-proxy', false);
 				}
+
 				ConfigUtil.setConfigItem('useSystemProxy', newValue);
 				this.updateProxyOption();
 			}
@@ -123,6 +126,7 @@ class NetworkSection extends BaseSection {
 				if (systemProxyValue && newValue) {
 					ConfigUtil.setConfigItem('useSystemProxy', !systemProxyValue);
 				}
+
 				ConfigUtil.setConfigItem('proxyRules', '');
 				ConfigUtil.setConfigItem('useManualProxy', newValue);
 				// Reload app only when turning manual proxy off, hence !newValue
@@ -132,5 +136,3 @@ class NetworkSection extends BaseSection {
 		});
 	}
 }
-
-export = NetworkSection;

app/renderer/js/pages/preference/new-server-form.ts

@@ -1,18 +1,23 @@
-'use strict';
+import {ipcRenderer, remote} from 'electron';
 
-import { shell, ipcRenderer } from 'electron';
+import BaseComponent from '../../components/base';
+import * as DomainUtil from '../../utils/domain-util';
+import * as LinkUtil from '../../utils/link-util';
+import * as t from '../../utils/translation-util';
 
-import BaseComponent = require('../../components/base');
-import DomainUtil = require('../../utils/domain-util');
-import t = require('../../utils/translation-util');
+const {dialog} = remote;
 
-class NewServerForm extends BaseComponent {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+interface NewServerFormProps {
+	$root: Element;
+	onChange: () => void;
+}
+
+export default class NewServerForm extends BaseComponent {
+	props: NewServerFormProps;
 	$newServerForm: Element;
 	$saveServerButton: HTMLButtonElement;
 	$newServerUrl: HTMLInputElement;
-	constructor(props: any) {
+	constructor(props: NewServerFormProps) {
 		super();
 		this.props = props;
 	}
@@ -25,9 +30,7 @@ class NewServerForm extends BaseComponent {
 					<input class="setting-input-value" autofocus placeholder="your-organization.zulipchat.com or zulip.your-organization.com"/>
 				</div>
 				<div class="server-center">
-					<div class="server-save-action">
-						<button id="connect">${t.__('Connect')}</button>
-					</div>
+					<button id="connect">${t.__('Connect')}</button>
 				</div>
 				<div class="server-center">
 					<div class="divider">
@@ -35,9 +38,7 @@ class NewServerForm extends BaseComponent {
 					</div>
 				</div>
 				<div class="server-center">
-					<div class="server-save-action">
-						<button id="open-create-org-link">${t.__('Create a new organization')}</button>
-					</div>
+					<button id="open-create-org-link">${t.__('Create a new organization')}</button>
 				</div>
 				<div class="server-center">
 					<div class="server-network-option">
@@ -56,29 +57,36 @@ class NewServerForm extends BaseComponent {
 
 	initForm(): void {
 		this.$newServerForm = this.generateNodeFromTemplate(this.template());
-		this.$saveServerButton = this.$newServerForm.querySelectorAll('.server-save-action')[0] as HTMLButtonElement;
+		this.$saveServerButton = this.$newServerForm.querySelector('#connect');
 		this.props.$root.innerHTML = '';
 		this.props.$root.append(this.$newServerForm);
 		this.$newServerUrl = this.$newServerForm.querySelectorAll('input.setting-input-value')[0] as HTMLInputElement;
 	}
 
-	submitFormHandler(): void {
-		this.$saveServerButton.children[0].innerHTML = 'Connecting...';
-		DomainUtil.checkDomain(this.$newServerUrl.value).then(serverConf => {
-			DomainUtil.addDomain(serverConf).then(() => {
-				this.props.onChange(this.props.index);
+	async submitFormHandler(): Promise<void> {
+		this.$saveServerButton.innerHTML = 'Connecting...';
+		let serverConf;
+		try {
+			serverConf = await DomainUtil.checkDomain(this.$newServerUrl.value);
+		} catch (error) {
+			this.$saveServerButton.innerHTML = 'Connect';
+			await dialog.showMessageBox({
+				type: 'error',
+				message: error.toString(),
+				buttons: ['OK']
 			});
-		}, errorMessage => {
-			this.$saveServerButton.children[0].innerHTML = 'Connect';
-			alert(errorMessage);
-		});
+			return;
+		}
+
+		await DomainUtil.addDomain(serverConf);
+		this.props.onChange();
 	}
 
 	openCreateNewOrgExternalLink(): void {
 		const link = 'https://zulipchat.com/new/';
-		const externalCreateNewOrgEl = document.querySelector('#open-create-org-link');
-		externalCreateNewOrgEl.addEventListener('click', () => {
-			shell.openExternal(link);
+		const externalCreateNewOrgElement = document.querySelector('#open-create-org-link');
+		externalCreateNewOrgElement.addEventListener('click', async () => {
+			await LinkUtil.openBrowser(new URL(link));
 		});
 	}
 
@@ -88,20 +96,16 @@ class NewServerForm extends BaseComponent {
 	}
 
 	initActions(): void {
-		this.$saveServerButton.addEventListener('click', () => {
-			this.submitFormHandler();
+		this.$saveServerButton.addEventListener('click', async () => {
+			await this.submitFormHandler();
 		});
-		this.$newServerUrl.addEventListener('keypress', event => {
-			const EnterkeyCode = event.keyCode;
-			// Submit form when Enter key is pressed
-			if (EnterkeyCode === 13) {
-				this.submitFormHandler();
+		this.$newServerUrl.addEventListener('keypress', async event => {
+			if (event.key === 'Enter') {
+				await this.submitFormHandler();
 			}
 		});
-		// open create new org link in default browser
+		// Open create new org link in default browser
 		this.openCreateNewOrgExternalLink();
 		this.networkSettingsLink();
 	}
 }
-
-export = NewServerForm;

app/renderer/js/pages/preference/preference.ts

@@ -1,18 +1,17 @@
-'use strict';
+import {ipcRenderer} from 'electron';
 
-import { ipcRenderer } from 'electron';
-
-import BaseComponent = require('../../components/base');
-import Nav = require('./nav');
-import ServersSection = require('./servers-section');
-import GeneralSection = require('./general-section');
-import NetworkSection = require('./network-section');
-import ConnectedOrgSection = require('./connected-org-section');
-import ShortcutsSection = require('./shortcuts-section');
+import BaseComponent from '../../components/base';
+import Nav from './nav';
+import ServersSection from './servers-section';
+import GeneralSection from './general-section';
+import NetworkSection from './network-section';
+import ConnectedOrgSection from './connected-org-section';
+import ShortcutsSection from './shortcuts-section';
+import type {DNDSettings} from '../../utils/dnd-util';
 
 type Section = ServersSection | GeneralSection | NetworkSection | ConnectedOrgSection | ShortcutsSection;
 
-class PreferenceView extends BaseComponent {
+export default class PreferenceView extends BaseComponent {
 	$sidebarContainer: Element;
 	$settingsContainer: Element;
 	nav: Nav;
@@ -37,8 +36,9 @@ class PreferenceView extends BaseComponent {
 		let nav = 'General';
 		const hasTag = window.location.hash;
 		if (hasTag) {
-			nav = hasTag.substring(1);
+			nav = hasTag.slice(1);
 		}
+
 		this.handleNavigation(nav);
 	}
 
@@ -51,32 +51,38 @@ class PreferenceView extends BaseComponent {
 				});
 				break;
 			}
+
 			case 'General': {
 				this.section = new GeneralSection({
 					$root: this.$settingsContainer
 				});
 				break;
 			}
+
 			case 'Organizations': {
 				this.section = new ConnectedOrgSection({
 					$root: this.$settingsContainer
 				});
 				break;
 			}
+
 			case 'Network': {
 				this.section = new NetworkSection({
 					$root: this.$settingsContainer
 				});
 				break;
 			}
+
 			case 'Shortcuts': {
 				this.section = new ShortcutsSection({
 					$root: this.$settingsContainer
 				});
 				break;
 			}
+
 			default: break;
 		}
+
 		this.section.init();
 		window.location.hash = `#${navItem}`;
 	}
@@ -107,7 +113,7 @@ class PreferenceView extends BaseComponent {
 			this.handleToggle('tray-option', state);
 		});
 
-		ipcRenderer.on('toggle-dnd', (_event: Event, _state: boolean, newSettings: any) => {
+		ipcRenderer.on('toggle-dnd', (_event: Event, _state: boolean, newSettings: DNDSettings) => {
 			this.handleToggle('show-notification-option', newSettings.showNotification);
 			this.handleToggle('silent-option', newSettings.silent);
 
@@ -122,5 +128,3 @@ window.addEventListener('load', () => {
 	const preferenceView = new PreferenceView();
 	preferenceView.init();
 });
-
-export = PreferenceView;

app/renderer/js/pages/preference/server-info-form.ts

@@ -1,23 +1,27 @@
-'use strict';
+import {remote, ipcRenderer} from 'electron';
 
-import { remote, ipcRenderer } from 'electron';
+import BaseComponent from '../../components/base';
+import * as DomainUtil from '../../utils/domain-util';
+import * as Messages from '../../../../resources/messages';
+import * as t from '../../utils/translation-util';
 
-import BaseComponent = require('../../components/base');
-import DomainUtil = require('../../utils/domain-util');
-import Messages = require('./../../../../resources/messages');
-import t = require('../../utils/translation-util');
+const {dialog} = remote;
 
-const { dialog } = remote;
+interface ServerInfoFormProps {
+	$root: Element;
+	server: DomainUtil.ServerConf;
+	index: number;
+	onChange: () => void;
+}
 
-class ServerInfoForm extends BaseComponent {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+export default class ServerInfoForm extends BaseComponent {
+	props: ServerInfoFormProps;
 	$serverInfoForm: Element;
 	$serverInfoAlias: Element;
 	$serverIcon: Element;
 	$deleteServerButton: Element;
 	$openServerButton: Element;
-	constructor(props: any) {
+	constructor(props: ServerInfoFormProps) {
 		super();
 		this.props = props;
 	}
@@ -61,22 +65,21 @@ class ServerInfoForm extends BaseComponent {
 	}
 
 	initActions(): void {
-		this.$deleteServerButton.addEventListener('click', () => {
-			dialog.showMessageBox({
+		this.$deleteServerButton.addEventListener('click', async () => {
+			const {response} = await dialog.showMessageBox({
 				type: 'warning',
 				buttons: [t.__('YES'), t.__('NO')],
 				defaultId: 0,
 				message: t.__('Are you sure you want to disconnect this organization?')
-			}, response => {
-				if (response === 0) {
-					if (DomainUtil.removeDomain(this.props.index)) {
-						ipcRenderer.send('reload-full-app');
-					} else {
-						const { title, content } = Messages.orgRemovalError(DomainUtil.getDomain(this.props.index).url);
-						dialog.showErrorBox(title, content);
-					}
-				}
 			});
+			if (response === 0) {
+				if (DomainUtil.removeDomain(this.props.index)) {
+					ipcRenderer.send('reload-full-app');
+				} else {
+					const {title, content} = Messages.orgRemovalError(DomainUtil.getDomain(this.props.index).url);
+					dialog.showErrorBox(title, content);
+				}
+			}
 		});
 
 		this.$openServerButton.addEventListener('click', () => {
@@ -92,5 +95,3 @@ class ServerInfoForm extends BaseComponent {
 		});
 	}
 }
-
-export = ServerInfoForm;

app/renderer/js/pages/preference/servers-section.ts

@@ -1,14 +1,15 @@
-'use strict';
+import BaseSection from './base-section';
+import NewServerForm from './new-server-form';
+import * as t from '../../utils/translation-util';
 
-import BaseSection = require('./base-section');
-import NewServerForm = require('./new-server-form');
-import t = require('../../utils/translation-util');
+interface ServersSectionProps {
+	$root: Element;
+}
 
-class ServersSection extends BaseSection {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
+export default class ServersSection extends BaseSection {
+	props: ServersSectionProps;
 	$newServerContainer: Element;
-	constructor(props: any) {
+	constructor(props: ServersSectionProps) {
 		super();
 		this.props = props;
 	}
@@ -46,5 +47,3 @@ class ServersSection extends BaseSection {
 		}).init();
 	}
 }
-
-export = ServersSection;

app/renderer/js/pages/preference/shortcuts-section.ts

@@ -1,17 +1,18 @@
-'use strict';
+import BaseSection from './base-section';
+import * as LinkUtil from '../../utils/link-util';
+import * as t from '../../utils/translation-util';
 
-import { shell } from 'electron';
+interface ShortcutsSectionProps {
+	$root: Element;
+}
 
-import BaseSection = require('./base-section');
-import t = require('../../utils/translation-util');
-
-class ShortcutsSection extends BaseSection {
-	// TODO: TypeScript - Here props should be object type
-	props: any;
-	constructor(props: any) {
+export default class ShortcutsSection extends BaseSection {
+	props: ShortcutsSectionProps;
+	constructor(props: ShortcutsSectionProps) {
 		super();
 		this.props = props;
 	}
+
 	// TODO - Deduplicate templateMac and templateWinLin functions. In theory
 	// they both should be the same the only thing different should be the userOSKey
 	// variable but there seems to be inconsistences between both function, one has more
@@ -330,16 +331,15 @@ class ShortcutsSection extends BaseSection {
 
 	openHotkeysExternalLink(): void {
 		const link = 'https://zulipchat.com/help/keyboard-shortcuts';
-		const externalCreateNewOrgEl = document.querySelector('#open-hotkeys-link');
-		externalCreateNewOrgEl.addEventListener('click', () => {
-			shell.openExternal(link);
+		const externalCreateNewOrgElement = document.querySelector('#open-hotkeys-link');
+		externalCreateNewOrgElement.addEventListener('click', async () => {
+			await LinkUtil.openBrowser(new URL(link));
 		});
 	}
+
 	init(): void {
 		this.props.$root.innerHTML = (process.platform === 'darwin') ?
 			this.templateMac() : this.templateWinLin();
 		this.openHotkeysExternalLink();
 	}
 }
-
-export = ShortcutsSection;

app/renderer/js/preload.ts

@@ -1,47 +1,31 @@
-// we have and will have some non camelcase stuff
-// while working with zulip and electron bridge
-// so turning the rule off for the whole file.
-/* eslint-disable @typescript-eslint/camelcase */
+import {contextBridge, ipcRenderer, webFrame} from 'electron';
+import fs from 'fs';
+import * as SetupSpellChecker from './spellchecker';
 
-'use strict';
+import isDev from 'electron-is-dev';
 
-import { ipcRenderer, shell } from 'electron';
-import SetupSpellChecker from './spellchecker';
-
-import isDev = require('electron-is-dev');
-import LinkUtil = require('./utils/link-util');
-import params = require('./utils/params-util');
-
-import NetworkError = require('./pages/network');
-
-interface PatchedGlobal extends NodeJS.Global {
-	logout: () => void;
-	shortcut: () => void;
-	showNotificationSettings: () => void;
-}
-
-const globalPatched = global as PatchedGlobal;
+import * as NetworkError from './pages/network';
 
 // eslint-disable-next-line import/no-unassigned-import
-require('./notification');
+import './notification';
 
 // Prevent drag and drop event in main process which prevents remote code executaion
-require(__dirname + '/shared/preventdrag.js');
+// eslint-disable-next-line import/no-unassigned-import
+import './shared/preventdrag';
 
-declare let window: ZulipWebWindow;
+import electron_bridge from './electron-bridge';
+contextBridge.exposeInMainWorld('raw_electron_bridge', electron_bridge);
 
-window.electron_bridge = require('./electron-bridge');
-
-const logout = (): void => {
+ipcRenderer.on('logout', () => {
 	// Create the menu for the below
 	const dropdown: HTMLElement = document.querySelector('.dropdown-toggle');
 	dropdown.click();
 
 	const nodes: NodeListOf<HTMLElement> = document.querySelectorAll('.dropdown-menu li:last-child a');
 	nodes[nodes.length - 1].click();
-};
+});
 
-const shortcut = (): void => {
+ipcRenderer.on('shortcut', () => {
 	// Create the menu for the below
 	const node: HTMLElement = document.querySelector('a[data-overlay-trigger=keyboard-shortcuts]');
 	// Additional check
@@ -52,9 +36,9 @@ const shortcut = (): void => {
 		const dropdown: HTMLElement = document.querySelector('.dropdown-toggle');
 		dropdown.click();
 	}
-};
+});
 
-const showNotificationSettings = (): void => {
+ipcRenderer.on('show-notification-settings', () => {
 	// Create the menu for the below
 	const dropdown: HTMLElement = document.querySelector('.dropdown-toggle');
 	dropdown.click();
@@ -64,54 +48,24 @@ const showNotificationSettings = (): void => {
 
 	const notificationItem: NodeListOf<HTMLElement> = document.querySelectorAll('.normal-settings-list li div');
 
-	// wait until the notification dom element shows up
+	// Wait until the notification dom element shows up
 	setTimeout(() => {
 		notificationItem[2].click();
 	}, 100);
-};
-
-process.once('loaded', (): void => {
-	globalPatched.logout = logout;
-	globalPatched.shortcut = shortcut;
-	globalPatched.showNotificationSettings = showNotificationSettings;
 });
 
-// To prevent failing this script on linux we need to load it after the document loaded
-document.addEventListener('DOMContentLoaded', (): void => {
-	if (params.isPageParams()) {
+electron_bridge.once('zulip-loaded', ({serverLanguage}) => {
 	// Get the default language of the server
-		const serverLanguage = page_params.default_language; // eslint-disable-line no-undef
-		if (serverLanguage) {
-			// Init spellchecker
-			SetupSpellChecker.init(serverLanguage);
-		}
-		// redirect users to network troubleshooting page
-		const getRestartButton = document.querySelector('.restart_get_events_button');
-		if (getRestartButton) {
-			getRestartButton.addEventListener('click', () => {
-				ipcRenderer.send('forward-message', 'reload-viewer');
-			});
-		}
-		// Open image attachment link in the lightbox instead of opening in the default browser
-		const { $, lightbox } = window;
-		$('#main_div').on('click', '.message_content p a', function (this: HTMLElement, e: Event) {
-			const url = $(this).attr('href');
+	if (serverLanguage) {
+		// Init spellchecker
+		SetupSpellChecker.init(serverLanguage);
+	}
 
-			if (LinkUtil.isImage(url)) {
-				const $img = $(this).parent().siblings('.message_inline_image').find('img');
-
-				// prevent the image link from opening in a new page.
-				e.preventDefault();
-				// prevent the message compose dialog from happening.
-				e.stopPropagation();
-
-				// Open image in the default browser if image preview is unavailable
-				if (!$img[0]) {
-					shell.openExternal(window.location.origin + url);
-				}
-				// Open image in lightbox
-				lightbox.open($img);
-			}
+	// Redirect users to network troubleshooting page
+	const getRestartButton = document.querySelector('.restart_get_events_button');
+	if (getRestartButton) {
+		getRestartButton.addEventListener('click', () => {
+			ipcRenderer.send('forward-message', 'reload-viewer');
 		});
 	}
 });
@@ -126,12 +80,13 @@ window.addEventListener('load', (event: any): void => {
 	if (!event.target.URL.includes('app/renderer/network.html')) {
 		return;
 	}
+
 	const $reconnectButton = document.querySelector('#reconnect');
 	const $settingsButton = document.querySelector('#settings');
 	NetworkError.init($reconnectButton, $settingsButton);
 });
 
-// electron's globalShortcut can cause unexpected results
+// Electron's globalShortcut can cause unexpected results
 // so adding the reload shortcut in the old-school way
 // Zoom from numpad keys is not supported by electron, so adding it through listeners.
 document.addEventListener('keydown', event => {
@@ -152,8 +107,9 @@ ipcRenderer.on('set-active', () => {
 	if (isDev) {
 		console.log('active');
 	}
-	window.electron_bridge.idle_on_system = false;
-	window.electron_bridge.last_active_on_system = Date.now();
+
+	electron_bridge.idle_on_system = false;
+	electron_bridge.last_active_on_system = Date.now();
 });
 
 // Set user as idle and time of last activity is left unchanged
@@ -161,5 +117,10 @@ ipcRenderer.on('set-idle', () => {
 	if (isDev) {
 		console.log('idle');
 	}
-	window.electron_bridge.idle_on_system = true;
+
+	electron_bridge.idle_on_system = true;
 });
+
+(async () => webFrame.executeJavaScript(
+	fs.readFileSync(require.resolve('./injected'), 'utf8')
+))();

app/renderer/js/shared/preventdrag.ts

@@ -1,5 +1,3 @@
-'use strict';
-
 // This is a security fix. Following function prevents drag and drop event in the app
 // so that attackers can't execute any remote code within the app
 // It doesn't affect the compose box so that users can still
@@ -15,3 +13,5 @@ const preventDragAndDrop = (): void => {
 };
 
 preventDragAndDrop();
+
+export {};

app/renderer/js/spellchecker.ts

@@ -1,56 +1,61 @@
-'use strict';
+import type {Subject} from 'rxjs';
+import {SpellCheckHandler, ContextMenuListener, ContextMenuBuilder} from 'electron-spellchecker';
 
-import { SpellCheckHandler, ContextMenuListener, ContextMenuBuilder } from 'electron-spellchecker';
+import * as ConfigUtil from './utils/config-util';
+import Logger from './utils/logger-util';
 
-import ConfigUtil = require('./utils/config-util');
-import Logger = require('./utils/logger-util');
+declare module 'electron-spellchecker' {
+	interface SpellCheckHandler {
+		currentSpellcheckerChanged: Subject<true>;
+		currentSpellcheckerLanguage: string;
+	}
+}
 
 const logger = new Logger({
 	file: 'errors.log',
 	timestamp: true
 });
 
-class SetupSpellChecker {
-	SpellCheckHandler: typeof SpellCheckHandler;
-	contextMenuListener: typeof ContextMenuListener;
-	init(serverLanguage: string): void {
-		if (ConfigUtil.getConfigItem('enableSpellchecker')) {
-			this.enableSpellChecker();
-		}
-		this.enableContextMenu(serverLanguage);
+let spellCheckHandler: SpellCheckHandler;
+let contextMenuListener: ContextMenuListener;
+
+export function init(serverLanguage: string): void {
+	if (ConfigUtil.getConfigItem('enableSpellchecker')) {
+		enableSpellChecker();
 	}
 
-	enableSpellChecker(): void {
-		try {
-			this.SpellCheckHandler = new SpellCheckHandler();
-		} catch (err) {
-			logger.error(err);
-		}
-	}
+	enableContextMenu(serverLanguage);
+}
 
-	enableContextMenu(serverLanguage: string): void {
-		if (this.SpellCheckHandler) {
-			this.SpellCheckHandler.attachToInput();
-			this.SpellCheckHandler.switchLanguage(serverLanguage);
-			this.SpellCheckHandler.currentSpellcheckerChanged.subscribe(() => {
-				this.SpellCheckHandler.switchLanguage(this.SpellCheckHandler.currentSpellcheckerLanguage);
-			});
-		}
-
-		const contextMenuBuilder = new ContextMenuBuilder(this.SpellCheckHandler);
-		this.contextMenuListener = new ContextMenuListener((info: object) => {
-			contextMenuBuilder.showPopupMenu(info);
-		});
-	}
-
-	unsubscribeSpellChecker(): void {
-		if (this.SpellCheckHandler) {
-			this.SpellCheckHandler.unsubscribe();
-		}
-		if (this.contextMenuListener) {
-			this.contextMenuListener.unsubscribe();
-		}
+function enableSpellChecker(): void {
+	try {
+		spellCheckHandler = new SpellCheckHandler();
+	} catch (error) {
+		logger.error(error);
 	}
 }
 
-export = new SetupSpellChecker();
+function enableContextMenu(serverLanguage: string): void {
+	if (spellCheckHandler) {
+		spellCheckHandler.attachToInput();
+		spellCheckHandler.switchLanguage(serverLanguage);
+		spellCheckHandler.currentSpellcheckerChanged.subscribe(() => {
+			spellCheckHandler.switchLanguage(spellCheckHandler.currentSpellcheckerLanguage);
+		});
+	}
+
+	const contextMenuBuilder = new ContextMenuBuilder(spellCheckHandler);
+	contextMenuListener = new ContextMenuListener(info => {
+		contextMenuBuilder.showPopupMenu(info);
+	});
+}
+
+export function unsubscribeSpellChecker(): void {
+	if (spellCheckHandler) {
+		spellCheckHandler.unsubscribe();
+	}
+
+	if (contextMenuListener) {
+		contextMenuListener.unsubscribe();
+	}
+}

app/renderer/js/tray.ts

@@ -1,18 +1,26 @@
-'use strict';
-import { ipcRenderer, remote, WebviewTag, NativeImage } from 'electron';
+import {ipcRenderer, remote, WebviewTag, NativeImage} from 'electron';
 
-import path = require('path');
-import ConfigUtil = require('./utils/config-util.js');
-const { Tray, Menu, nativeImage, BrowserWindow } = remote;
+import path from 'path';
+import * as ConfigUtil from './utils/config-util';
 
-const APP_ICON = path.join(__dirname, '../../resources/tray', 'tray');
+const {Tray, Menu, nativeImage, BrowserWindow, nativeTheme} = remote;
 
-declare let window: ZulipWebWindow;
+let tray: Electron.Tray;
+
+// Get the theme on macOS
+const theme = nativeTheme.shouldUseDarkColors ? 'dark' : 'light';
+
+const ICON_DIR = process.platform === 'darwin' ? `../../resources/tray/${theme}` : '../../resources/tray';
+
+const TRAY_SUFFIX = 'tray';
+
+const APP_ICON = path.join(__dirname, ICON_DIR, TRAY_SUFFIX);
 
 const iconPath = (): string => {
 	if (process.platform === 'linux') {
 		return APP_ICON + 'linux.png';
 	}
+
 	return APP_ICON + (process.platform === 'win32' ? 'win.ico' : 'osx.png');
 };
 
@@ -43,69 +51,60 @@ const config = {
 	thick: process.platform === 'win32'
 };
 
-const renderCanvas = function (arg: number): Promise<HTMLCanvasElement> {
+const renderCanvas = function (arg: number): HTMLCanvasElement {
 	config.unreadCount = arg;
 
-	return new Promise(resolve => {
-		const SIZE = config.size * config.pixelRatio;
-		const PADDING = SIZE * 0.05;
-		const CENTER = SIZE / 2;
-		const HAS_COUNT = config.showUnreadCount && config.unreadCount;
-		const color = config.unreadCount ? config.unreadColor : config.readColor;
-		const backgroundColor = config.unreadCount ? config.unreadBackgroundColor : config.readBackgroundColor;
+	const SIZE = config.size * config.pixelRatio;
+	const PADDING = SIZE * 0.05;
+	const CENTER = SIZE / 2;
+	const HAS_COUNT = config.showUnreadCount && config.unreadCount;
+	const color = config.unreadCount ? config.unreadColor : config.readColor;
+	const backgroundColor = config.unreadCount ? config.unreadBackgroundColor : config.readBackgroundColor;
 
-		const canvas = document.createElement('canvas');
-		canvas.width = SIZE;
-		canvas.height = SIZE;
-		const ctx = canvas.getContext('2d');
+	const canvas = document.createElement('canvas');
+	canvas.width = SIZE;
+	canvas.height = SIZE;
+	const ctx = canvas.getContext('2d');
 
-		// Circle
-		// If (!config.thick || config.thick && HAS_COUNT) {
-		ctx.beginPath();
-		ctx.arc(CENTER, CENTER, (SIZE / 2) - PADDING, 0, 2 * Math.PI, false);
-		ctx.fillStyle = backgroundColor;
-		ctx.fill();
-		ctx.lineWidth = SIZE / (config.thick ? 10 : 20);
-		ctx.strokeStyle = backgroundColor;
-		ctx.stroke();
-		// Count or Icon
-		if (HAS_COUNT) {
-			ctx.fillStyle = color;
-			ctx.textAlign = 'center';
-			if (config.unreadCount > 99) {
-				ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.4}px Helvetica`;
-				ctx.fillText('99+', CENTER, CENTER + (SIZE * 0.15));
-			} else if (config.unreadCount < 10) {
-				ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.5}px Helvetica`;
-				ctx.fillText(String(config.unreadCount), CENTER, CENTER + (SIZE * 0.20));
-			} else {
-				ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.5}px Helvetica`;
-				ctx.fillText(String(config.unreadCount), CENTER, CENTER + (SIZE * 0.15));
-			}
-
-			resolve(canvas);
+	// Circle
+	// If (!config.thick || config.thick && HAS_COUNT) {
+	ctx.beginPath();
+	ctx.arc(CENTER, CENTER, (SIZE / 2) - PADDING, 0, 2 * Math.PI, false);
+	ctx.fillStyle = backgroundColor;
+	ctx.fill();
+	ctx.lineWidth = SIZE / (config.thick ? 10 : 20);
+	ctx.strokeStyle = backgroundColor;
+	ctx.stroke();
+	// Count or Icon
+	if (HAS_COUNT) {
+		ctx.fillStyle = color;
+		ctx.textAlign = 'center';
+		if (config.unreadCount > 99) {
+			ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.4}px Helvetica`;
+			ctx.fillText('99+', CENTER, CENTER + (SIZE * 0.15));
+		} else if (config.unreadCount < 10) {
+			ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.5}px Helvetica`;
+			ctx.fillText(String(config.unreadCount), CENTER, CENTER + (SIZE * 0.2));
+		} else {
+			ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.5}px Helvetica`;
+			ctx.fillText(String(config.unreadCount), CENTER, CENTER + (SIZE * 0.15));
 		}
-	});
+	}
+
+	return canvas;
 };
+
 /**
  * Renders the tray icon as a native image
  * @param arg: Unread count
  * @return the native image
  */
-const renderNativeImage = function (arg: number): Promise<NativeImage> {
-	return Promise.resolve()
-		.then(() => renderCanvas(arg))
-		.then(canvas => {
-			const pngData = nativeImage.createFromDataURL(canvas.toDataURL('image/png')).toPNG();
-
-			// TODO: Fix the function to correctly use Promise correctly.
-			// the Promise.resolve().then(...) above is useless we should
-			// start with renderCanvas(arg).then
-			// eslint-disable-next-line promise/no-return-wrap
-			return Promise.resolve(nativeImage.createFromBuffer(pngData, {
-				scaleFactor: config.pixelRatio
-			}));
-		});
+const renderNativeImage = function (arg: number): NativeImage {
+	const canvas = renderCanvas(arg);
+	const pngData = nativeImage.createFromDataURL(canvas.toDataURL('image/png')).toPNG();
+	return nativeImage.createFromBuffer(pngData, {
+		scaleFactor: config.pixelRatio
+	});
 };
 
 function sendAction(action: string): void {
@@ -119,7 +118,6 @@ function sendAction(action: string): void {
 }
 
 const createTray = function (): void {
-	window.tray = new Tray(iconPath());
 	const contextMenu = Menu.buildFromTemplate([
 		{
 			label: 'Zulip',
@@ -144,22 +142,23 @@ const createTray = function (): void {
 			}
 		}
 	]);
-	window.tray.setContextMenu(contextMenu);
+	tray = new Tray(iconPath());
+	tray.setContextMenu(contextMenu);
 	if (process.platform === 'linux' || process.platform === 'win32') {
-		window.tray.on('click', () => {
+		tray.on('click', () => {
 			ipcRenderer.send('toggle-app');
 		});
 	}
 };
 
 ipcRenderer.on('destroytray', (event: Event): Event => {
-	if (!window.tray) {
+	if (!tray) {
 		return undefined;
 	}
 
-	window.tray.destroy();
-	if (window.tray.isDestroyed()) {
-		window.tray = null;
+	tray.destroy();
+	if (tray.isDestroyed()) {
+		tray = null;
 	} else {
 		throw new Error('Tray icon not properly destroyed.');
 	}
@@ -168,45 +167,47 @@ ipcRenderer.on('destroytray', (event: Event): Event => {
 });
 
 ipcRenderer.on('tray', (_event: Event, arg: number): void => {
-	if (!window.tray) {
+	if (!tray) {
 		return;
 	}
+
 	// We don't want to create tray from unread messages on macOS since it already has dock badges.
 	if (process.platform === 'linux' || process.platform === 'win32') {
 		if (arg === 0) {
 			unread = arg;
-			window.tray.setImage(iconPath());
-			window.tray.setToolTip('No unread messages');
+			tray.setImage(iconPath());
+			tray.setToolTip('No unread messages');
 		} else {
 			unread = arg;
-			renderNativeImage(arg).then(image => {
-				window.tray.setImage(image);
-				window.tray.setToolTip(arg + ' unread messages');
-			});
+			const image = renderNativeImage(arg);
+			tray.setImage(image);
+			tray.setToolTip(`${arg} unread messages`);
 		}
 	}
 });
 
 function toggleTray(): void {
 	let state;
-	if (window.tray) {
+	if (tray) {
 		state = false;
-		window.tray.destroy();
-		if (window.tray.isDestroyed()) {
-			window.tray = null;
+		tray.destroy();
+		if (tray.isDestroyed()) {
+			tray = null;
 		}
+
 		ConfigUtil.setConfigItem('trayIcon', false);
 	} else {
 		state = true;
 		createTray();
 		if (process.platform === 'linux' || process.platform === 'win32') {
-			renderNativeImage(unread).then(image => {
-				window.tray.setImage(image);
-				window.tray.setToolTip(unread + ' unread messages');
-			});
+			const image = renderNativeImage(unread);
+			tray.setImage(image);
+			tray.setToolTip(`${unread} unread messages`);
 		}
+
 		ConfigUtil.setConfigItem('trayIcon', true);
 	}
+
 	const selector = 'webview:not([class*=disabled])';
 	const webview: WebviewTag = document.querySelector(selector);
 	const webContents = webview.getWebContents();
@@ -218,3 +219,5 @@ ipcRenderer.on('toggletray', toggleTray);
 if (ConfigUtil.getConfigItem('trayIcon', true)) {
 	createTray();
 }
+
+export {};

app/renderer/js/utils/certificate-util.ts

@@ -1,96 +1,78 @@
-'use strict';
+import electron from 'electron';
+import {JsonDB} from 'node-json-db';
+import {initSetUp} from './default-util';
 
-import { remote } from 'electron';
-import JsonDB from 'node-json-db';
-import { initSetUp } from './default-util';
+import fs from 'fs';
+import path from 'path';
+import Logger from './logger-util';
 
-import fs = require('fs');
-import path = require('path');
-import Logger = require('./logger-util');
-
-const { app, dialog } = remote;
+const {app, dialog} =
+	process.type === 'renderer' ? electron.remote : electron;
 
 initSetUp();
 
 const logger = new Logger({
-	file: `certificate-util.log`,
+	file: 'certificate-util.log',
 	timestamp: true
 });
 
-let instance: null | CertificateUtil = null;
 const certificatesDir = `${app.getPath('userData')}/certificates`;
 
-class CertificateUtil {
-	db: JsonDB;
+let db: JsonDB;
 
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
+reloadDB();
 
-		this.reloadDB();
-		return instance;
-	}
-
-	getCertificate(server: string, defaultValue: any = null): any {
-		this.reloadDB();
-		const value = this.db.getData('/')[server];
-		if (value === undefined) {
-			return defaultValue;
-		} else {
-			return value;
-		}
-	}
-
-	// Function to copy the certificate to userData folder
-	copyCertificate(_server: string, location: string, fileName: string): boolean {
-		let copied = false;
-		const filePath = `${certificatesDir}/${fileName}`;
-		try {
-			fs.copyFileSync(location, filePath);
-			copied = true;
-		} catch (err) {
-			dialog.showErrorBox(
-				'Error saving certificate',
-				'We encountered error while saving the certificate.'
-			);
-			logger.error('Error while copying the certificate to certificates folder.');
-			logger.error(err);
-		}
-		return copied;
-	}
-
-	setCertificate(server: string, fileName: string): void {
-		const filePath = `${fileName}`;
-		this.db.push(`/${server}`, filePath, true);
-		this.reloadDB();
-	}
-
-	removeCertificate(server: string): void {
-		this.db.delete(`/${server}`);
-		this.reloadDB();
-	}
-
-	reloadDB(): void {
-		const settingsJsonPath = path.join(app.getPath('userData'), '/config/certificates.json');
-		try {
-			const file = fs.readFileSync(settingsJsonPath, 'utf8');
-			JSON.parse(file);
-		} catch (err) {
-			if (fs.existsSync(settingsJsonPath)) {
-				fs.unlinkSync(settingsJsonPath);
-				dialog.showErrorBox(
-					'Error saving settings',
-					'We encountered error while saving the certificate.'
-				);
-				logger.error('Error while JSON parsing certificates.json: ');
-				logger.error(err);
-			}
-		}
-		this.db = new JsonDB(settingsJsonPath, true, true);
-	}
+export function getCertificate(server: string): string | undefined {
+	reloadDB();
+	return db.getData('/')[server];
 }
 
-export = new CertificateUtil();
+// Function to copy the certificate to userData folder
+export function copyCertificate(_server: string, location: string, fileName: string): boolean {
+	let copied = false;
+	const filePath = `${certificatesDir}/${fileName}`;
+	try {
+		fs.copyFileSync(location, filePath);
+		copied = true;
+	} catch (error) {
+		dialog.showErrorBox(
+			'Error saving certificate',
+			'We encountered error while saving the certificate.'
+		);
+		logger.error('Error while copying the certificate to certificates folder.');
+		logger.error(error);
+	}
+
+	return copied;
+}
+
+export function setCertificate(server: string, fileName: string): void {
+	const filePath = `${fileName}`;
+	db.push(`/${server}`, filePath, true);
+	reloadDB();
+}
+
+export function removeCertificate(server: string): void {
+	db.delete(`/${server}`);
+	reloadDB();
+}
+
+function reloadDB(): void {
+	const settingsJsonPath = path.join(app.getPath('userData'), '/config/certificates.json');
+	try {
+		const file = fs.readFileSync(settingsJsonPath, 'utf8');
+		JSON.parse(file);
+	} catch (error) {
+		if (fs.existsSync(settingsJsonPath)) {
+			fs.unlinkSync(settingsJsonPath);
+			dialog.showErrorBox(
+				'Error saving settings',
+				'We encountered error while saving the certificate.'
+			);
+			logger.error('Error while JSON parsing certificates.json: ');
+			logger.error(error);
+		}
+	}
+
+	db = new JsonDB(settingsJsonPath, true, true);
+}

app/renderer/js/utils/common-util.ts

@@ -1,25 +1,8 @@
-'use strict';
-
-let instance: null | CommonUtil = null;
-
-class CommonUtil {
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
-		return instance;
-	}
-
-	// unescape already encoded/escaped strings
-	decodeString(stringInput: string): string {
-		const parser = new DOMParser();
-		const dom = parser.parseFromString(
-			'<!doctype html><body>' + stringInput,
-			'text/html');
-		return dom.body.textContent;
-	}
+// Unescape already encoded/escaped strings
+export function decodeString(stringInput: string): string {
+	const parser = new DOMParser();
+	const dom = parser.parseFromString(
+		'<!doctype html><body>' + stringInput,
+		'text/html');
+	return dom.body.textContent;
 }
-
-export = new CommonUtil();

app/renderer/js/utils/config-util.ts

@@ -1,24 +1,22 @@
-'use strict';
-import JsonDB from 'node-json-db';
+import {JsonDB} from 'node-json-db';
 
-import fs = require('fs');
-import path = require('path');
-import electron = require('electron');
-import Logger = require('./logger-util');
-import EnterpriseUtil = require('./enterprise-util');
+import fs from 'fs';
+import path from 'path';
+import electron from 'electron';
+import Logger from './logger-util';
+import * as EnterpriseUtil from './enterprise-util';
 
 const logger = new Logger({
 	file: 'config-util.log',
 	timestamp: true
 });
 
-let instance: null | ConfigUtil = null;
 let dialog: Electron.Dialog = null;
 let app: Electron.App = null;
 
 /* To make the util runnable in both main and renderer process */
 if (process.type === 'renderer') {
-	const { remote } = electron;
+	const {remote} = electron;
 	dialog = remote.dialog;
 	app = remote.app;
 } else {
@@ -26,81 +24,82 @@ if (process.type === 'renderer') {
 	app = electron.app;
 }
 
-class ConfigUtil {
-	db: JsonDB;
+let db: JsonDB;
 
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
+reloadDB();
 
-		this.reloadDB();
-		return instance;
+export function getConfigItem(key: string, defaultValue: unknown = null): any {
+	try {
+		db.reload();
+	} catch (error) {
+		logger.error('Error while reloading settings.json: ');
+		logger.error(error);
 	}
 
-	getConfigItem(key: string, defaultValue: any = null): any {
-		try {
-			this.db.reload();
-		} catch (err) {
-			logger.error('Error while reloading settings.json: ');
-			logger.error(err);
-		}
-		const value = this.db.getData('/')[key];
-		if (value === undefined) {
-			this.setConfigItem(key, defaultValue);
-			return defaultValue;
-		} else {
-			return value;
-		}
+	const value = db.getData('/')[key];
+	if (value === undefined) {
+		setConfigItem(key, defaultValue);
+		return defaultValue;
 	}
 
-	// This function returns whether a key exists in the configuration file (settings.json)
-	isConfigItemExists(key: string): boolean {
-		try {
-			this.db.reload();
-		} catch (err) {
-			logger.error('Error while reloading settings.json: ');
-			logger.error(err);
-		}
-		const value = this.db.getData('/')[key];
-		return (value !== undefined);
-	}
-
-	setConfigItem(key: string, value: any, override? : boolean): void {
-		if (EnterpriseUtil.configItemExists(key) && !override) {
-			// if item is in global config and we're not trying to override
-			return;
-		}
-		this.db.push(`/${key}`, value, true);
-		this.db.save();
-	}
-
-	removeConfigItem(key: string): void {
-		this.db.delete(`/${key}`);
-		this.db.save();
-	}
-
-	reloadDB(): void {
-		const settingsJsonPath = path.join(app.getPath('userData'), '/config/settings.json');
-		try {
-			const file = fs.readFileSync(settingsJsonPath, 'utf8');
-			JSON.parse(file);
-		} catch (err) {
-			if (fs.existsSync(settingsJsonPath)) {
-				fs.unlinkSync(settingsJsonPath);
-				dialog.showErrorBox(
-					'Error saving settings',
-					'We encountered an error while saving the settings.'
-				);
-				logger.error('Error while JSON parsing settings.json: ');
-				logger.error(err);
-				logger.reportSentry(err);
-			}
-		}
-		this.db = new JsonDB(settingsJsonPath, true, true);
-	}
+	return value;
 }
 
-export = new ConfigUtil();
+export function getConfigString(key: string, defaultValue: string): string {
+	const value = getConfigItem(key, defaultValue);
+	if (typeof value === 'string') {
+		return value;
+	}
+
+	setConfigItem(key, defaultValue);
+	return defaultValue;
+}
+
+// This function returns whether a key exists in the configuration file (settings.json)
+export function isConfigItemExists(key: string): boolean {
+	try {
+		db.reload();
+	} catch (error) {
+		logger.error('Error while reloading settings.json: ');
+		logger.error(error);
+	}
+
+	const value = db.getData('/')[key];
+	return (value !== undefined);
+}
+
+export function setConfigItem(key: string, value: unknown, override? : boolean): void {
+	if (EnterpriseUtil.configItemExists(key) && !override) {
+		// If item is in global config and we're not trying to override
+		return;
+	}
+
+	db.push(`/${key}`, value, true);
+	db.save();
+}
+
+export function removeConfigItem(key: string): void {
+	db.delete(`/${key}`);
+	db.save();
+}
+
+function reloadDB(): void {
+	const settingsJsonPath = path.join(app.getPath('userData'), '/config/settings.json');
+	try {
+		const file = fs.readFileSync(settingsJsonPath, 'utf8');
+		JSON.parse(file);
+	} catch (error) {
+		if (fs.existsSync(settingsJsonPath)) {
+			fs.unlinkSync(settingsJsonPath);
+			dialog.showErrorBox(
+				'Error saving settings',
+				'We encountered an error while saving the settings.'
+			);
+			logger.error('Error while JSON parsing settings.json: ');
+			logger.error(error);
+			logger.reportSentry(error);
+		}
+	}
+
+	db = new JsonDB(settingsJsonPath, true, true);
+}

app/renderer/js/utils/default-util.ts

@@ -1,11 +1,12 @@
-import fs = require('fs');
+import electron from 'electron';
+import fs from 'fs';
 
 let app: Electron.App = null;
 let setupCompleted = false;
 if (process.type === 'renderer') {
-	app = require('electron').remote.app;
+	app = electron.remote.app;
 } else {
-	app = require('electron').app;
+	app = electron.app;
 }
 
 const zulipDir = app.getPath('userData');
@@ -13,7 +14,7 @@ const logDir = `${zulipDir}/Logs/`;
 const certificatesDir = `${zulipDir}/certificates/`;
 const configDir = `${zulipDir}/config/`;
 export const initSetUp = (): void => {
-	// if it is the first time the app is running
+	// If it is the first time the app is running
 	// create zulip dir in userData folder to
 	// avoid errors
 	if (!setupCompleted) {
@@ -41,19 +42,19 @@ export const initSetUp = (): void => {
 			const configData = [
 				{
 					path: domainJson,
-					fileName: `domain.json`
+					fileName: 'domain.json'
 				},
 				{
 					path: certificatesJson,
-					fileName: `certificates.json`
+					fileName: 'certificates.json'
 				},
 				{
 					path: settingsJson,
-					fileName: `settings.json`
+					fileName: 'settings.json'
 				},
 				{
 					path: updatesJson,
-					fileName: `updates.json`
+					fileName: 'updates.json'
 				}
 			];
 			configData.forEach(data => {
@@ -62,7 +63,7 @@ export const initSetUp = (): void => {
 					fs.unlinkSync(data.path);
 				}
 			});
-			// window-state.json is only deleted not moved, as the electron-window-state
+			// `window-state.json` is only deleted not moved, as the electron-window-state
 			// package will recreate the file in the config folder.
 			if (fs.existsSync(windowStateJson)) {
 				fs.unlinkSync(windowStateJson);

app/renderer/js/utils/dnd-util.ts

@@ -1,30 +1,28 @@
-'use strict';
+import * as ConfigUtil from './config-util';
 
-import ConfigUtil = require('./config-util');
+type SettingName = 'showNotification' | 'silent' | 'flashTaskbarOnMessage';
 
-// TODO: TypeScript - add to Setting interface
-// the list of settings since we have fixed amount of them
-// We want to do this by creating a new module that exports
-// this interface
-interface Setting {
-	[key: string]: any;
+export interface DNDSettings {
+	showNotification?: boolean;
+	silent?: boolean;
+	flashTaskbarOnMessage?: boolean;
 }
 
 interface Toggle {
 	dnd: boolean;
-	newSettings: Setting;
+	newSettings: DNDSettings;
 }
 
 export function toggle(): Toggle {
 	const dnd = !ConfigUtil.getConfigItem('dnd', false);
-	const dndSettingList = ['showNotification', 'silent'];
+	const dndSettingList: SettingName[] = ['showNotification', 'silent'];
 	if (process.platform === 'win32') {
 		dndSettingList.push('flashTaskbarOnMessage');
 	}
 
-	let newSettings: Setting;
+	let newSettings: DNDSettings;
 	if (dnd) {
-		const oldSettings: Setting = {};
+		const oldSettings: DNDSettings = {};
 		newSettings = {};
 
 		// Iterate through the dndSettingList.

app/renderer/js/utils/domain-util.ts

@@ -1,331 +1,321 @@
-'use strict';
-import JsonDB from 'node-json-db';
+import {JsonDB} from 'node-json-db';
 
-import escape = require('escape-html');
-import request = require('request');
-import fs = require('fs');
-import path = require('path');
-import Logger = require('./logger-util');
-import electron = require('electron');
+import escape from 'escape-html';
+import request from 'request';
+import fs from 'fs';
+import path from 'path';
+import Logger from './logger-util';
+import {remote} from 'electron';
 
-import RequestUtil = require('./request-util');
-import EnterpriseUtil = require('./enterprise-util');
-import Messages = require('../../../resources/messages');
+import * as RequestUtil from './request-util';
+import * as EnterpriseUtil from './enterprise-util';
+import * as Messages from '../../../resources/messages';
 
-const { ipcRenderer } = electron;
-const { app, dialog } = electron.remote;
+const {app, dialog} = remote;
+
+export interface ServerConf {
+	url: string;
+	alias?: string;
+	icon?: string;
+	ignoreCerts?: boolean;
+}
 
 const logger = new Logger({
-	file: `domain-util.log`,
+	file: 'domain-util.log',
 	timestamp: true
 });
 
-let instance: null | DomainUtil = null;
-
 const defaultIconUrl = '../renderer/img/icon.png';
 
-class DomainUtil {
-	db: JsonDB;
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
+let db: JsonDB;
 
-		this.reloadDB();
-		// Migrate from old schema
-		if (this.db.getData('/').domain) {
-			this.addDomain({
-				alias: 'Zulip',
-				url: this.db.getData('/domain')
-			});
-			this.db.delete('/domain');
-		}
-
-		return instance;
-	}
-
-	getDomains(): any {
-		this.reloadDB();
-		if (this.db.getData('/').domains === undefined) {
-			return [];
-		} else {
-			return this.db.getData('/domains');
-		}
-	}
-
-	getDomain(index: number): any {
-		this.reloadDB();
-		return this.db.getData(`/domains[${index}]`);
-	}
-
-	shouldIgnoreCerts(url: string): boolean {
-		const domains = this.getDomains();
-		for (const domain of domains) {
-			if (domain.url === url) {
-				return domain.ignoreCerts;
-			}
-		}
-		return null;
-	}
-
-	updateDomain(index: number, server: object): void {
-		this.reloadDB();
-		this.db.push(`/domains[${index}]`, server, true);
-	}
-
-	addDomain(server: any): Promise<void> {
-		const { ignoreCerts } = server;
-		return new Promise(resolve => {
-			if (server.icon) {
-				this.saveServerIcon(server, ignoreCerts).then(localIconUrl => {
-					server.icon = localIconUrl;
-					this.db.push('/domains[]', server, true);
-					this.reloadDB();
-					resolve();
-				});
-			} else {
-				server.icon = defaultIconUrl;
-				this.db.push('/domains[]', server, true);
-				this.reloadDB();
-				resolve();
-			}
+reloadDB();
+// Migrate from old schema
+if (db.getData('/').domain) {
+	(async () => {
+		await addDomain({
+			alias: 'Zulip',
+			url: db.getData('/domain')
 		});
+		db.delete('/domain');
+	})();
+}
+
+export function getDomains(): ServerConf[] {
+	reloadDB();
+	if (db.getData('/').domains === undefined) {
+		return [];
 	}
 
-	removeDomains(): void {
-		this.db.delete('/domains');
-		this.reloadDB();
-	}
+	return db.getData('/domains');
+}
 
-	removeDomain(index: number): boolean {
-		if (EnterpriseUtil.isPresetOrg(this.getDomain(index).url)) {
-			return false;
+export function getDomain(index: number): ServerConf {
+	reloadDB();
+	return db.getData(`/domains[${index}]`);
+}
+
+export function shouldIgnoreCerts(url: string): boolean {
+	const domains = getDomains();
+	for (const domain of domains) {
+		if (domain.url === url) {
+			return domain.ignoreCerts;
 		}
-		this.db.delete(`/domains[${index}]`);
-		this.reloadDB();
-		return true;
 	}
 
-	// Check if domain is already added
-	duplicateDomain(domain: any): boolean {
-		domain = this.formatUrl(domain);
-		const servers = this.getDomains();
-		for (const i in servers) {
-			if (servers[i].url === domain) {
-				return true;
-			}
-		}
+	return null;
+}
+
+export function updateDomain(index: number, server: ServerConf): void {
+	reloadDB();
+	db.push(`/domains[${index}]`, server, true);
+}
+
+export async function addDomain(server: ServerConf): Promise<void> {
+	const {ignoreCerts} = server;
+	if (server.icon) {
+		const localIconUrl = await saveServerIcon(server, ignoreCerts);
+		server.icon = localIconUrl;
+		db.push('/domains[]', server, true);
+		reloadDB();
+	} else {
+		server.icon = defaultIconUrl;
+		db.push('/domains[]', server, true);
+		reloadDB();
+	}
+}
+
+export function removeDomains(): void {
+	db.delete('/domains');
+	reloadDB();
+}
+
+export function removeDomain(index: number): boolean {
+	if (EnterpriseUtil.isPresetOrg(getDomain(index).url)) {
 		return false;
 	}
 
-	async checkCertError(domain: any, serverConf: any, error: string, silent: boolean): Promise<string | object> {
-		if (silent) {
-			// since getting server settings has already failed
-			return serverConf;
-		} else {
-			// Report error to sentry to get idea of possible certificate errors
-			// users get when adding the servers
-			logger.reportSentry(new Error(error).toString());
-			const certErrorMessage = Messages.certErrorMessage(domain, error);
-			const certErrorDetail = Messages.certErrorDetail();
+	db.delete(`/domains[${index}]`);
+	reloadDB();
+	return true;
+}
 
-			const response = await (dialog.showMessageBox({
-				type: 'warning',
-				buttons: ['Yes', 'No'],
-				defaultId: 1,
-				message: certErrorMessage,
-				detail: certErrorDetail
-			}) as any); // TODO: TypeScript - Figure this out
-			if (response === 0) {
-				// set ignoreCerts parameter to true in case user responds with yes
-				serverConf.ignoreCerts = true;
-				try {
-					return await this.getServerSettings(domain, serverConf.ignoreCerts);
-				} catch (_) {
-					if (error === Messages.noOrgsError(domain)) {
-						throw new Error(error);
-					}
-					return serverConf;
-				}
-			} else {
-				throw new Error('Untrusted certificate.');
-			}
-		}
+// Check if domain is already added
+export function duplicateDomain(domain: string): boolean {
+	domain = formatUrl(domain);
+	return getDomains().some(server => server.url === domain);
+}
+
+async function checkCertError(domain: string, serverConf: ServerConf, error: any, silent: boolean): Promise<ServerConf> {
+	if (silent) {
+		// Since getting server settings has already failed
+		return serverConf;
 	}
 
-	// ignoreCerts parameter helps in fetching server icon and
-	// other server details when user chooses to ignore certificate warnings
-	async checkDomain(domain: any, ignoreCerts = false, silent = false): Promise<any> {
-		if (!silent && this.duplicateDomain(domain)) {
-			// Do not check duplicate in silent mode
-			throw new Error('This server has been added.');
-		}
-
-		domain = this.formatUrl(domain);
-
-		const serverConf = {
-			icon: defaultIconUrl,
-			url: domain,
-			alias: domain,
-			ignoreCerts
-		};
+	// Report error to sentry to get idea of possible certificate errors
+	// users get when adding the servers
+	logger.reportSentry(error);
+	const certErrorMessage = Messages.certErrorMessage(domain, error);
+	const certErrorDetail = Messages.certErrorDetail();
 
+	const {response} = await dialog.showMessageBox({
+		type: 'warning',
+		buttons: ['Yes', 'No'],
+		defaultId: 1,
+		message: certErrorMessage,
+		detail: certErrorDetail
+	});
+	if (response === 0) {
+		// Set ignoreCerts parameter to true in case user responds with yes
+		serverConf.ignoreCerts = true;
 		try {
-			return await this.getServerSettings(domain, serverConf.ignoreCerts);
-		} catch (err) {
-			// If the domain contains following strings we just bypass the server
-			const whitelistDomains = [
-				'zulipdev.org'
-			];
-
-			// make sure that error is an error or string not undefined
-			// so validation does not throw error.
-			const error = err || '';
-
-			const certsError = error.toString().includes('certificate');
-			if (domain.indexOf(whitelistDomains) >= 0 || certsError) {
-				return this.checkCertError(domain, serverConf, error, silent);
-			} else {
-				throw Messages.invalidZulipServerError(domain);
+			return await getServerSettings(domain, serverConf.ignoreCerts);
+		} catch (_) {
+			if (error === Messages.noOrgsError(domain)) {
+				throw new Error(error);
 			}
+
+			return serverConf;
 		}
+	} else {
+		throw new Error('Untrusted certificate.');
+	}
+}
+
+// ignoreCerts parameter helps in fetching server icon and
+// other server details when user chooses to ignore certificate warnings
+export async function checkDomain(domain: string, ignoreCerts = false, silent = false): Promise<ServerConf> {
+	if (!silent && duplicateDomain(domain)) {
+		// Do not check duplicate in silent mode
+		throw new Error('This server has been added.');
 	}
 
-	getServerSettings(domain: any, ignoreCerts = false): Promise<object | string> {
-		const serverSettingsOptions = {
-			url: domain + '/api/v1/server_settings',
-			...RequestUtil.requestOptions(domain, ignoreCerts)
-		};
+	domain = formatUrl(domain);
 
-		return new Promise((resolve, reject) => {
-			request(serverSettingsOptions, (error: string, response: any) => {
-				if (!error && response.statusCode === 200) {
-					const data = JSON.parse(response.body);
-					if (data.hasOwnProperty('realm_icon') && data.realm_icon) {
-						resolve({
-							// Some Zulip Servers use absolute URL for server icon whereas others use relative URL
-							// Following check handles both the cases
-							icon: data.realm_icon.startsWith('/') ? data.realm_uri + data.realm_icon : data.realm_icon,
-							url: data.realm_uri,
-							alias: escape(data.realm_name),
-							ignoreCerts
-						});
-					} else {
-						reject(Messages.noOrgsError(domain));
-					}
+	const serverConf = {
+		icon: defaultIconUrl,
+		url: domain,
+		alias: domain,
+		ignoreCerts
+	};
+
+	try {
+		return await getServerSettings(domain, serverConf.ignoreCerts);
+	} catch (error_) {
+		// Make sure that error is an error or string not undefined
+		// so validation does not throw error.
+		const error = error_ || '';
+
+		const certsError = error.toString().includes('certificate');
+		if (certsError) {
+			const result = await checkCertError(domain, serverConf, error, silent);
+			return result;
+		}
+
+		throw new Error(Messages.invalidZulipServerError(domain));
+	}
+}
+
+async function getServerSettings(domain: string, ignoreCerts = false): Promise<ServerConf> {
+	const serverSettingsOptions = {
+		url: domain + '/api/v1/server_settings',
+		...RequestUtil.requestOptions(domain, ignoreCerts)
+	};
+
+	return new Promise((resolve, reject) => {
+		request(serverSettingsOptions, (error: Error, response: request.Response) => {
+			if (!error && response.statusCode === 200) {
+				const {realm_name, realm_uri, realm_icon} = JSON.parse(response.body);
+				if (
+					typeof realm_name === 'string' &&
+					typeof realm_uri === 'string' &&
+					typeof realm_icon === 'string'
+				) {
+					resolve({
+						// Some Zulip Servers use absolute URL for server icon whereas others use relative URL
+						// Following check handles both the cases
+						icon: realm_icon.startsWith('/') ? realm_uri + realm_icon : realm_icon,
+						url: realm_uri,
+						alias: escape(realm_name),
+						ignoreCerts
+					});
 				} else {
-					reject(response);
+					reject(Messages.noOrgsError(domain));
 				}
-			});
+			} else {
+				reject(response);
+			}
 		});
-	}
+	});
+}
 
-	saveServerIcon(server: any, ignoreCerts = false): Promise<string> {
-		const url = server.icon;
-		const domain = server.url;
+export async function saveServerIcon(server: ServerConf, ignoreCerts = false): Promise<string> {
+	const url = server.icon;
+	const domain = server.url;
 
-		const serverIconOptions = {
-			url,
-			...RequestUtil.requestOptions(domain, ignoreCerts)
-		};
+	const serverIconOptions = {
+		url,
+		...RequestUtil.requestOptions(domain, ignoreCerts)
+	};
 
-		// The save will always succeed. If url is invalid, downgrade to default icon.
-		return new Promise(resolve => {
-			const filePath = this.generateFilePath(url);
-			const file = fs.createWriteStream(filePath);
-			try {
-				request(serverIconOptions).on('response', (response: any) => {
-					response.on('error', (err: string) => {
-						logger.log('Could not get server icon.');
-						logger.log(err);
-						logger.reportSentry(err);
-						resolve(defaultIconUrl);
-					});
-					response.pipe(file).on('finish', () => {
-						resolve(filePath);
-					});
-				}).on('error', (err: string) => {
+	// The save will always succeed. If url is invalid, downgrade to default icon.
+	return new Promise(resolve => {
+		const filePath = generateFilePath(url);
+		const file = fs.createWriteStream(filePath);
+		try {
+			request(serverIconOptions).on('response', (response: request.Response) => {
+				response.on('error', (err: Error) => {
 					logger.log('Could not get server icon.');
 					logger.log(err);
 					logger.reportSentry(err);
 					resolve(defaultIconUrl);
 				});
-			} catch (err) {
+				response.pipe(file).on('finish', () => {
+					resolve(filePath);
+				});
+			}).on('error', (err: Error) => {
 				logger.log('Could not get server icon.');
 				logger.log(err);
 				logger.reportSentry(err);
 				resolve(defaultIconUrl);
-			}
-		});
-	}
-
-	async updateSavedServer(url: string, index: number): Promise<void> {
-		// Does not promise successful update
-		const oldIcon = this.getDomain(index).icon;
-		const { ignoreCerts } = this.getDomain(index);
-		try {
-			const newServerConf = await this.checkDomain(url, ignoreCerts, true);
-			const localIconUrl = await this.saveServerIcon(newServerConf, ignoreCerts);
-			if (!oldIcon || localIconUrl !== '../renderer/img/icon.png') {
-				newServerConf.icon = localIconUrl;
-				this.updateDomain(index, newServerConf);
-				this.reloadDB();
-			}
-		} catch (err) {
-			ipcRenderer.send('forward-message', 'show-network-error', index);
+			});
+		} catch (error) {
+			logger.log('Could not get server icon.');
+			logger.log(error);
+			logger.reportSentry(error);
+			resolve(defaultIconUrl);
 		}
-	}
+	});
+}
 
-	reloadDB(): void {
-		const domainJsonPath = path.join(app.getPath('userData'), 'config/domain.json');
-		try {
-			const file = fs.readFileSync(domainJsonPath, 'utf8');
-			JSON.parse(file);
-		} catch (err) {
-			if (fs.existsSync(domainJsonPath)) {
-				fs.unlinkSync(domainJsonPath);
-				dialog.showErrorBox(
-					'Error saving new organization',
-					'There seems to be error while saving new organization, ' +
-					'you may have to re-add your previous organizations back.'
-				);
-				logger.error('Error while JSON parsing domain.json: ');
-				logger.error(err);
-				logger.reportSentry(err);
-			}
-		}
-		this.db = new JsonDB(domainJsonPath, true, true);
-	}
-
-	generateFilePath(url: string): string {
-		const dir = `${app.getPath('userData')}/server-icons`;
-		const extension = path.extname(url).split('?')[0];
-
-		let hash = 5381;
-		let len = url.length;
-
-		while (len) {
-			hash = (hash * 33) ^ url.charCodeAt(--len);
-		}
-
-		// Create 'server-icons' directory if not existed
-		if (!fs.existsSync(dir)) {
-			fs.mkdirSync(dir);
-		}
-
-		return `${dir}/${hash >>> 0}${extension}`;
-	}
-
-	formatUrl(domain: any): string {
-		const hasPrefix = (domain.indexOf('http') === 0);
-		if (hasPrefix) {
-			return domain;
-		} else {
-			return (domain.indexOf('localhost:') >= 0) ? `http://${domain}` : `https://${domain}`;
+export async function updateSavedServer(url: string, index: number): Promise<void> {
+	// Does not promise successful update
+	const oldIcon = getDomain(index).icon;
+	const {ignoreCerts} = getDomain(index);
+	try {
+		const newServerConf = await checkDomain(url, ignoreCerts, true);
+		const localIconUrl = await saveServerIcon(newServerConf, ignoreCerts);
+		if (!oldIcon || localIconUrl !== '../renderer/img/icon.png') {
+			newServerConf.icon = localIconUrl;
+			updateDomain(index, newServerConf);
+			reloadDB();
 		}
+	} catch (error) {
+		logger.log('Could not update server icon.');
+		logger.log(error);
+		logger.reportSentry(error);
 	}
 }
 
-export = new DomainUtil();
+function reloadDB(): void {
+	const domainJsonPath = path.join(app.getPath('userData'), 'config/domain.json');
+	try {
+		const file = fs.readFileSync(domainJsonPath, 'utf8');
+		JSON.parse(file);
+	} catch (error) {
+		if (fs.existsSync(domainJsonPath)) {
+			fs.unlinkSync(domainJsonPath);
+			dialog.showErrorBox(
+				'Error saving new organization',
+				'There seems to be error while saving new organization, ' +
+				'you may have to re-add your previous organizations back.'
+			);
+			logger.error('Error while JSON parsing domain.json: ');
+			logger.error(error);
+			logger.reportSentry(error);
+		}
+	}
+
+	db = new JsonDB(domainJsonPath, true, true);
+}
+
+function generateFilePath(url: string): string {
+	const dir = `${app.getPath('userData')}/server-icons`;
+	const extension = path.extname(url).split('?')[0];
+
+	let hash = 5381;
+	let {length} = url;
+
+	while (length) {
+		hash = (hash * 33) ^ url.charCodeAt(--length);
+	}
+
+	// Create 'server-icons' directory if not existed
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir);
+	}
+
+	return `${dir}/${hash >>> 0}${extension}`;
+}
+
+export function formatUrl(domain: string): string {
+	if (domain.startsWith('http://') || domain.startsWith('https://')) {
+		return domain;
+	}
+
+	if (domain.startsWith('localhost:')) {
+		return `http://${domain}`;
+	}
+
+	return `https://${domain}`;
+}

app/renderer/js/utils/enterprise-util.ts

@@ -1,80 +1,81 @@
-import fs = require('fs');
-import path = require('path');
+import fs from 'fs';
+import path from 'path';
 
-import Logger = require('./logger-util');
+import Logger from './logger-util';
 
 const logger = new Logger({
 	file: 'enterprise-util.log',
 	timestamp: true
 });
 
-let instance: null | EnterpriseUtil = null;
+// TODO: replace enterpriseSettings type with an interface once settings are final
+let enterpriseSettings: {[key: string]: unknown};
+let configFile: boolean;
 
-class EnterpriseUtil {
-	// todo: replace enterpriseSettings type with an interface once settings are final
-	enterpriseSettings: any;
-	configFile: boolean;
-	constructor() {
-		if (instance) {
-			return instance;
-		}
-		instance = this;
+reloadDB();
 
-		this.reloadDB();
+function reloadDB(): void {
+	let enterpriseFile = '/etc/zulip-desktop-config/global_config.json';
+	if (process.platform === 'win32') {
+		enterpriseFile = 'C:\\Program Files\\Zulip-Desktop-Config\\global_config.json';
 	}
 
-	reloadDB(): void {
-		let enterpriseFile = '/etc/zulip-desktop-config/global_config.json';
-		if (process.platform === 'win32') {
-			enterpriseFile = 'C:\\Program Files\\Zulip-Desktop-Config\\global_config.json';
+	enterpriseFile = path.resolve(enterpriseFile);
+	if (fs.existsSync(enterpriseFile)) {
+		configFile = true;
+		try {
+			const file = fs.readFileSync(enterpriseFile, 'utf8');
+			enterpriseSettings = JSON.parse(file);
+		} catch (error) {
+			logger.log('Error while JSON parsing global_config.json: ');
+			logger.log(error);
 		}
-
-		enterpriseFile = path.resolve(enterpriseFile);
-		if (fs.existsSync(enterpriseFile)) {
-			this.configFile = true;
-			try {
-				const file = fs.readFileSync(enterpriseFile, 'utf8');
-				this.enterpriseSettings = JSON.parse(file);
-			} catch (err) {
-				logger.log('Error while JSON parsing global_config.json: ');
-				logger.log(err);
-			}
-		} else {
-			this.configFile = false;
-		}
-	}
-
-	getConfigItem(key: string, defaultValue?: any): any {
-		this.reloadDB();
-		if (!this.configFile) {
-			return defaultValue;
-		}
-		if (defaultValue === undefined) {
-			defaultValue = null;
-		}
-		return this.configItemExists(key) ? this.enterpriseSettings[key] : defaultValue;
-	}
-
-	configItemExists(key: string): boolean {
-		this.reloadDB();
-		if (!this.configFile) {
-			return false;
-		}
-		return (this.enterpriseSettings[key] !== undefined);
-	}
-
-	isPresetOrg(url: string): boolean {
-		if (!this.configFile || !this.configItemExists('presetOrganizations')) {
-			return false;
-		}
-		const presetOrgs = this.enterpriseSettings.presetOrganizations;
-		for (const org of presetOrgs) {
-			if (url.includes(org)) {
-				return true;
-			}
-		}
-		return false;
+	} else {
+		configFile = false;
 	}
 }
 
-export = new EnterpriseUtil();
+export function hasConfigFile(): boolean {
+	return configFile;
+}
+
+export function getConfigItem(key: string, defaultValue?: unknown): any {
+	reloadDB();
+	if (!configFile) {
+		return defaultValue;
+	}
+
+	if (defaultValue === undefined) {
+		defaultValue = null;
+	}
+
+	return configItemExists(key) ? enterpriseSettings[key] : defaultValue;
+}
+
+export function configItemExists(key: string): boolean {
+	reloadDB();
+	if (!configFile) {
+		return false;
+	}
+
+	return (enterpriseSettings[key] !== undefined);
+}
+
+export function isPresetOrg(url: string): boolean {
+	if (!configFile || !configItemExists('presetOrganizations')) {
+		return false;
+	}
+
+	const presetOrgs = enterpriseSettings.presetOrganizations;
+	if (!Array.isArray(presetOrgs)) {
+		throw new TypeError('Expected array for presetOrgs');
+	}
+
+	for (const org of presetOrgs) {
+		if (url.includes(org)) {
+			return true;
+		}
+	}
+
+	return false;
+}

app/renderer/js/utils/link-util.ts

@@ -1,51 +1,45 @@
-'use strict';
+import {shell} from 'electron';
+import escape from 'escape-html';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 
-// TODO: TypeScript - Add @types/
-import wurl = require('wurl');
-
-let instance: null | LinkUtil = null;
-
-interface IsInternalResponse {
-	isInternalUrl: boolean;
-	isUploadsUrl: boolean;
+export function isUploadsUrl(server: string, url: URL): boolean {
+	return url.origin === server && url.pathname.startsWith('/user_uploads/');
 }
 
-class LinkUtil {
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
-
-		return instance;
-	}
-
-	isInternal(currentUrl: string, newUrl: string): IsInternalResponse {
-		const currentDomain = wurl('hostname', currentUrl);
-		const newDomain = wurl('hostname', newUrl);
-
-		const sameDomainUrl = (currentDomain === newDomain || newUrl === currentUrl + '/');
-		const isUploadsUrl = newUrl.includes(currentUrl + '/user_uploads/');
-		const isInternalUrl = newUrl.includes('/#narrow') || isUploadsUrl;
-
-		return {
-			isInternalUrl: sameDomainUrl && isInternalUrl,
-			isUploadsUrl
-		};
-	}
-
-	isImage(url: string): boolean {
-		// test for images extension as well as urls like .png?s=100
-		const isImageUrl = /\.(bmp|gif|jpg|jpeg|png|webp)\?*.*$/i;
-		return isImageUrl.test(url);
-	}
-
-	isPDF(url: string): boolean {
-		// test for pdf extension
-		const isPDFUrl = /\.(pdf)\?*.*$/i;
-		return isPDFUrl.test(url);
+export async function openBrowser(url: URL): Promise<void> {
+	if (['http:', 'https:', 'mailto:'].includes(url.protocol)) {
+		await shell.openExternal(url.href);
+	} else {
+		// For security, indirect links to non-whitelisted protocols
+		// through a real web browser via a local HTML file.
+		const dir = fs.mkdtempSync(
+			path.join(os.tmpdir(), 'zulip-redirect-')
+		);
+		const file = path.join(dir, 'redirect.html');
+		fs.writeFileSync(file, `\
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8" />
+        <meta http-equiv="Refresh" content="0; url=${escape(url.href)}" />
+        <title>Redirecting</title>
+        <style>
+            html {
+                font-family: menu, "Helvetica Neue", sans-serif;
+            }
+        </style>
+    </head>
+    <body>
+        <p>Opening <a href="${escape(url.href)}">${escape(url.href)}</a>…</p>
+    </body>
+</html>
+`);
+		shell.openItem(file);
+		setTimeout(() => {
+			fs.unlinkSync(file);
+			fs.rmdirSync(dir);
+		}, 15000);
 	}
 }
-
-export = new LinkUtil();

app/renderer/js/utils/linux-update-util.ts

@@ -1,10 +1,9 @@
-'use strict';
-import JsonDB from 'node-json-db';
+import {JsonDB} from 'node-json-db';
 
-import fs = require('fs');
-import path = require('path');
-import electron = require('electron');
-import Logger = require('./logger-util');
+import fs from 'fs';
+import path from 'path';
+import electron from 'electron';
+import Logger from './logger-util';
 
 const remote =
 	process.type === 'renderer' ? electron.remote : electron;
@@ -15,62 +14,49 @@ const logger = new Logger({
 });
 
 /* To make the util runnable in both main and renderer process */
-const { dialog, app } = remote;
-let instance: null | LinuxUpdateUtil = null;
+const {dialog, app} = remote;
 
-class LinuxUpdateUtil {
-	db: JsonDB;
+let db: JsonDB;
 
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
+reloadDB();
 
-		this.reloadDB();
-		return instance;
+export function getUpdateItem(key: string, defaultValue: unknown = null): any {
+	reloadDB();
+	const value = db.getData('/')[key];
+	if (value === undefined) {
+		setUpdateItem(key, defaultValue);
+		return defaultValue;
 	}
 
-	getUpdateItem(key: string, defaultValue: any = null): any {
-		this.reloadDB();
-		const value = this.db.getData('/')[key];
-		if (value === undefined) {
-			this.setUpdateItem(key, defaultValue);
-			return defaultValue;
-		} else {
-			return value;
-		}
-	}
-
-	setUpdateItem(key: string, value: any): void {
-		this.db.push(`/${key}`, value, true);
-		this.reloadDB();
-	}
-
-	removeUpdateItem(key: string): void {
-		this.db.delete(`/${key}`);
-		this.reloadDB();
-	}
-
-	reloadDB(): void {
-		const linuxUpdateJsonPath = path.join(app.getPath('userData'), '/config/updates.json');
-		try {
-			const file = fs.readFileSync(linuxUpdateJsonPath, 'utf8');
-			JSON.parse(file);
-		} catch (err) {
-			if (fs.existsSync(linuxUpdateJsonPath)) {
-				fs.unlinkSync(linuxUpdateJsonPath);
-				dialog.showErrorBox(
-					'Error saving update notifications.',
-					'We encountered an error while saving the update notifications.'
-				);
-				logger.error('Error while JSON parsing updates.json: ');
-				logger.error(err);
-			}
-		}
-		this.db = new JsonDB(linuxUpdateJsonPath, true, true);
-	}
+	return value;
 }
 
-export = new LinuxUpdateUtil();
+export function setUpdateItem(key: string, value: unknown): void {
+	db.push(`/${key}`, value, true);
+	reloadDB();
+}
+
+export function removeUpdateItem(key: string): void {
+	db.delete(`/${key}`);
+	reloadDB();
+}
+
+function reloadDB(): void {
+	const linuxUpdateJsonPath = path.join(app.getPath('userData'), '/config/updates.json');
+	try {
+		const file = fs.readFileSync(linuxUpdateJsonPath, 'utf8');
+		JSON.parse(file);
+	} catch (error) {
+		if (fs.existsSync(linuxUpdateJsonPath)) {
+			fs.unlinkSync(linuxUpdateJsonPath);
+			dialog.showErrorBox(
+				'Error saving update notifications.',
+				'We encountered an error while saving the update notifications.'
+			);
+			logger.error('Error while JSON parsing updates.json: ');
+			logger.error(error);
+		}
+	}
+
+	db = new JsonDB(linuxUpdateJsonPath, true, true);
+}

app/renderer/js/utils/logger-util.ts

@@ -1,19 +1,14 @@
-import { Console as NodeConsole } from 'console'; // eslint-disable-line node/prefer-global/console
-import { initSetUp } from './default-util';
-import { sentryInit, captureException } from './sentry-util';
+import {Console} from 'console'; // eslint-disable-line node/prefer-global/console
+import {initSetUp} from './default-util';
+import {sentryInit, captureException} from './sentry-util';
 
-import fs = require('fs');
-import os = require('os');
-import isDev = require('electron-is-dev');
-import electron = require('electron');
-// this interface adds [key: string]: any so
-// we can do console[type] later on in the code
-interface PatchedConsole extends Console {
-	[key: string]: any;
-}
+import fs from 'fs';
+import os from 'os';
+import isDev from 'electron-is-dev';
+import electron from 'electron';
 
 interface LoggerOptions {
-	timestamp?: any;
+	timestamp?: true | (() => string);
 	file?: string;
 	level?: boolean;
 	logInDevMode?: boolean;
@@ -29,9 +24,9 @@ if (process.type === 'renderer') {
 	// Report Errors to Sentry only if it is enabled in settings
 	// Gets the value of reportErrors from config-util for renderer process
 	// For main process, sentryInit() is handled in index.js
-	const { ipcRenderer } = electron;
+	const {ipcRenderer} = electron;
 	ipcRenderer.send('error-reporting');
-	ipcRenderer.on('error-reporting-val', (_event: any, errorReporting: boolean) => {
+	ipcRenderer.on('error-reporting-val', (_event: Event, errorReporting: boolean) => {
 		reportErrors = errorReporting;
 		if (reportErrors) {
 			sentryInit();
@@ -41,23 +36,31 @@ if (process.type === 'renderer') {
 	app = electron.app;
 }
 
-const browserConsole: PatchedConsole = console;
 const logDir = `${app.getPath('userData')}/Logs`;
 
-class Logger {
-	nodeConsole: PatchedConsole;
-	timestamp: any; // TODO: TypeScript - Figure out how to make this work with string | Function.
+type Level = 'log' | 'debug' | 'info' | 'warn' | 'error';
+const levels: Level[] = ['log', 'debug', 'info', 'warn', 'error'];
+type LogMethod = (...args: unknown[]) => void;
+
+export default class Logger {
+	log: LogMethod;
+	debug: LogMethod;
+	info: LogMethod;
+	warn: LogMethod;
+	error: LogMethod;
+
+	nodeConsole: Console;
+	timestamp?: () => string;
 	level: boolean;
 	logInDevMode: boolean;
-	[key: string]: any;
 
-	constructor(opts: LoggerOptions = {}) {
+	constructor(options: LoggerOptions = {}) {
 		let {
 			timestamp = true,
 			file = 'console.log',
 			level = true,
 			logInDevMode = false
-		} = opts;
+		} = options;
 
 		file = `${logDir}/${file}`;
 		if (timestamp === true) {
@@ -71,8 +74,8 @@ class Logger {
 			process.nextTick(() => this.trimLog(file));
 		}
 
-		const fileStream = fs.createWriteStream(file, { flags: 'a' });
-		const nodeConsole = new NodeConsole(fileStream);
+		const fileStream = fs.createWriteStream(file, {flags: 'a'});
+		const nodeConsole = new Console(fileStream);
 
 		this.nodeConsole = nodeConsole;
 		this.timestamp = timestamp;
@@ -81,42 +84,37 @@ class Logger {
 		this.setUpConsole();
 	}
 
-	_log(type: string, ...args: any[]): void {
+	_log(type: Level, ...args: unknown[]): void {
 		const {
 			nodeConsole, timestamp, level, logInDevMode
 		} = this;
-		let nodeConsoleLog;
 
 		/* eslint-disable no-fallthrough */
 		switch (true) {
 			case typeof timestamp === 'function':
 				args.unshift(timestamp() + ' |\t');
 
-			case (level !== false):
+			case (level):
 				args.unshift(type.toUpperCase() + ' |');
 
 			case isDev || logInDevMode:
-				nodeConsoleLog = nodeConsole[type] || nodeConsole.log;
-				nodeConsoleLog.apply(null, args); // eslint-disable-line prefer-spread
+				nodeConsole[type](...args);
 
 			default: break;
 		}
 		/* eslint-enable no-fallthrough */
 
-		browserConsole[type].apply(null, args);
+		console[type](...args);
 	}
 
 	setUpConsole(): void {
-		for (const type in browserConsole) {
+		for (const type of levels) {
 			this.setupConsoleMethod(type);
 		}
 	}
 
-	setupConsoleMethod(type: string): void {
-		this[type] = (...args: any[]) => {
-			const log = this._log.bind(this, type, ...args);
-			log();
-		};
+	setupConsoleMethod(type: Level): void {
+		this[type] = (...args: unknown[]) => this._log(type, ...args);
 	}
 
 	getTimestamp(): string {
@@ -127,7 +125,7 @@ class Logger {
 		return timestamp;
 	}
 
-	reportSentry(err: string): void {
+	reportSentry(err: unknown): void {
 		if (reportErrors) {
 			captureException(err);
 		}
@@ -138,6 +136,7 @@ class Logger {
 			if (err) {
 				throw err;
 			}
+
 			const MAX_LOG_FILE_LINES = 500;
 			const logs = data.split(os.EOL);
 			const logLength = logs.length - 1;
@@ -151,5 +150,3 @@ class Logger {
 		});
 	}
 }
-
-export = Logger;

app/renderer/js/utils/params-util.ts

@@ -1,11 +0,0 @@
-// This util function returns the page params if they're present else returns null
-export function isPageParams(): null | object {
-	let webpageParams = null;
-	try {
-		// eslint-disable-next-line no-undef, @typescript-eslint/camelcase
-		webpageParams = page_params;
-	} catch (_) {
-		webpageParams = null;
-	}
-	return webpageParams;
-}

app/renderer/js/utils/proxy-util.ts

@@ -1,142 +1,122 @@
-'use strict';
+import * as ConfigUtil from './config-util';
 
-import url = require('url');
-
-import ConfigUtil = require('./config-util');
-
-let instance: null | ProxyUtil = null;
-
-interface ProxyRule {
+export interface ProxyRule {
 	hostname?: string;
 	port?: number;
 }
 
-class ProxyUtil {
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
-		}
-
-		return instance;
+// Return proxy to be used for a particular uri, to be used for request
+export function getProxy(_uri: string): ProxyRule | void {
+	let uri;
+	try {
+		uri = new URL(_uri);
+	} catch (_) {
+		return;
 	}
 
-	// Return proxy to be used for a particular uri, to be used for request
-	getProxy(_uri: string): ProxyRule | void {
-		const parsedUri = url.parse(_uri);
-		if (parsedUri === null) {
-			return;
-		}
-
-		const uri = parsedUri;
-		const proxyRules = ConfigUtil.getConfigItem('proxyRules', '').split(';');
-		// If SPS is on and system uses no proxy then request should not try to use proxy from
-		// environment. NO_PROXY = '*' makes request ignore all environment proxy variables.
-		if (proxyRules[0] === '') {
-			process.env.NO_PROXY = '*';
-			return;
-		}
-
-		const proxyRule: any = {};
-		if (uri.protocol === 'http:') {
-			proxyRules.forEach((proxy: string) => {
-				if (proxy.includes('http=')) {
-					proxyRule.hostname = proxy.split('http=')[1].trim().split(':')[0];
-					proxyRule.port = proxy.split('http=')[1].trim().split(':')[1];
-				}
-			});
-			return proxyRule;
-		}
-
-		if (uri.protocol === 'https:') {
-			proxyRules.forEach((proxy: string) => {
-				if (proxy.includes('https=')) {
-					proxyRule.hostname = proxy.split('https=')[1].trim().split(':')[0];
-					proxyRule.port = proxy.split('https=')[1].trim().split(':')[1];
-				}
-			});
-			return proxyRule;
-		}
+	const proxyRules = ConfigUtil.getConfigItem('proxyRules', '').split(';');
+	// If SPS is on and system uses no proxy then request should not try to use proxy from
+	// environment. NO_PROXY = '*' makes request ignore all environment proxy variables.
+	if (proxyRules[0] === '') {
+		process.env.NO_PROXY = '*';
+		return;
 	}
 
-	// TODO: Refactor to async function
-	resolveSystemProxy(mainWindow: Electron.BrowserWindow): void {
-		const page = mainWindow.webContents;
-		const ses = page.session;
-		const resolveProxyUrl = 'www.example.com';
-
-		// Check HTTP Proxy
-		const httpProxy = new Promise(resolve => {
-			ses.resolveProxy('http://' + resolveProxyUrl, (proxy: string) => {
-				let httpString = '';
-				if (proxy !== 'DIRECT') {
-					// in case of proxy HTTPS url:port, windows gives first word as HTTPS while linux gives PROXY
-					// for all other HTTP or direct url:port both uses PROXY
-					if (proxy.includes('PROXY') || proxy.includes('HTTPS')) {
-						httpString = 'http=' + proxy.split('PROXY')[1] + ';';
-					}
-				}
-				resolve(httpString);
-			});
-		});
-		// Check HTTPS Proxy
-		const httpsProxy = new Promise(resolve => {
-			ses.resolveProxy('https://' + resolveProxyUrl, (proxy: string) => {
-				let httpsString = '';
-				if (proxy !== 'DIRECT' || proxy.includes('HTTPS')) {
-					// in case of proxy HTTPS url:port, windows gives first word as HTTPS while linux gives PROXY
-					// for all other HTTP or direct url:port both uses PROXY
-					if (proxy.includes('PROXY') || proxy.includes('HTTPS')) {
-						httpsString += 'https=' + proxy.split('PROXY')[1] + ';';
-					}
-				}
-				resolve(httpsString);
-			});
-		});
-
-		// Check FTP Proxy
-		const ftpProxy = new Promise(resolve => {
-			ses.resolveProxy('ftp://' + resolveProxyUrl, (proxy: string) => {
-				let ftpString = '';
-				if (proxy !== 'DIRECT') {
-					if (proxy.includes('PROXY')) {
-						ftpString += 'ftp=' + proxy.split('PROXY')[1] + ';';
-					}
-				}
-				resolve(ftpString);
-			});
-		});
-
-		// Check SOCKS Proxy
-		const socksProxy = new Promise(resolve => {
-			ses.resolveProxy('socks4://' + resolveProxyUrl, (proxy: string) => {
-				let socksString = '';
-				if (proxy !== 'DIRECT') {
-					if (proxy.includes('SOCKS5')) {
-						socksString += 'socks=' + proxy.split('SOCKS5')[1] + ';';
-					} else if (proxy.includes('SOCKS4')) {
-						socksString += 'socks=' + proxy.split('SOCKS4')[1] + ';';
-					} else if (proxy.includes('PROXY')) {
-						socksString += 'socks=' + proxy.split('PROXY')[1] + ';';
-					}
-				}
-				resolve(socksString);
-			});
-		});
-
-		Promise.all([httpProxy, httpsProxy, ftpProxy, socksProxy]).then(values => {
-			let proxyString = '';
-			values.forEach(proxy => {
-				proxyString += proxy;
-			});
-			ConfigUtil.setConfigItem('systemProxyRules', proxyString);
-			const useSystemProxy = ConfigUtil.getConfigItem('useSystemProxy');
-			if (useSystemProxy) {
-				ConfigUtil.setConfigItem('proxyRules', proxyString);
+	const proxyRule: any = {};
+	if (uri.protocol === 'http:') {
+		proxyRules.forEach((proxy: string) => {
+			if (proxy.includes('http=')) {
+				proxyRule.hostname = proxy.split('http=')[1].trim().split(':')[0];
+				proxyRule.port = proxy.split('http=')[1].trim().split(':')[1];
 			}
 		});
+		return proxyRule;
+	}
+
+	if (uri.protocol === 'https:') {
+		proxyRules.forEach((proxy: string) => {
+			if (proxy.includes('https=')) {
+				proxyRule.hostname = proxy.split('https=')[1].trim().split(':')[0];
+				proxyRule.port = proxy.split('https=')[1].trim().split(':')[1];
+			}
+		});
+		return proxyRule;
 	}
 }
 
-export = new ProxyUtil();
+// TODO: Refactor to async function
+export async function resolveSystemProxy(mainWindow: Electron.BrowserWindow): Promise<void> {
+	const page = mainWindow.webContents;
+	const ses = page.session;
+	const resolveProxyUrl = 'www.example.com';
+
+	// Check HTTP Proxy
+	const httpProxy = (async () => {
+		const proxy = await ses.resolveProxy('http://' + resolveProxyUrl);
+		let httpString = '';
+		if (proxy !== 'DIRECT') {
+			// In case of proxy HTTPS url:port, windows gives first word as HTTPS while linux gives PROXY
+			// for all other HTTP or direct url:port both uses PROXY
+			if (proxy.includes('PROXY') || proxy.includes('HTTPS')) {
+				httpString = 'http=' + proxy.split('PROXY')[1] + ';';
+			}
+		}
+
+		return httpString;
+	})();
+	// Check HTTPS Proxy
+	const httpsProxy = (async () => {
+		const proxy = await ses.resolveProxy('https://' + resolveProxyUrl);
+		let httpsString = '';
+		if (proxy !== 'DIRECT' || proxy.includes('HTTPS')) {
+			// In case of proxy HTTPS url:port, windows gives first word as HTTPS while linux gives PROXY
+			// for all other HTTP or direct url:port both uses PROXY
+			if (proxy.includes('PROXY') || proxy.includes('HTTPS')) {
+				httpsString += 'https=' + proxy.split('PROXY')[1] + ';';
+			}
+		}
+
+		return httpsString;
+	})();
+
+	// Check FTP Proxy
+	const ftpProxy = (async () => {
+		const proxy = await ses.resolveProxy('ftp://' + resolveProxyUrl);
+		let ftpString = '';
+		if (proxy !== 'DIRECT') {
+			if (proxy.includes('PROXY')) {
+				ftpString += 'ftp=' + proxy.split('PROXY')[1] + ';';
+			}
+		}
+
+		return ftpString;
+	})();
+
+	// Check SOCKS Proxy
+	const socksProxy = (async () => {
+		const proxy = await ses.resolveProxy('socks4://' + resolveProxyUrl);
+		let socksString = '';
+		if (proxy !== 'DIRECT') {
+			if (proxy.includes('SOCKS5')) {
+				socksString += 'socks=' + proxy.split('SOCKS5')[1] + ';';
+			} else if (proxy.includes('SOCKS4')) {
+				socksString += 'socks=' + proxy.split('SOCKS4')[1] + ';';
+			} else if (proxy.includes('PROXY')) {
+				socksString += 'socks=' + proxy.split('PROXY')[1] + ';';
+			}
+		}
+
+		return socksString;
+	})();
+
+	const values = await Promise.all([httpProxy, httpsProxy, ftpProxy, socksProxy]);
+	let proxyString = '';
+	values.forEach(proxy => {
+		proxyString += proxy;
+	});
+	ConfigUtil.setConfigItem('systemProxyRules', proxyString);
+	const useSystemProxy = ConfigUtil.getConfigItem('useSystemProxy');
+	if (useSystemProxy) {
+		ConfigUtil.setConfigItem('proxyRules', proxyString);
+	}
+}

app/renderer/js/utils/reconnect-util.ts

@@ -1,26 +1,24 @@
-import { ipcRenderer } from 'electron';
+import {ipcRenderer} from 'electron';
 
-import backoff = require('backoff');
-import request = require('request');
-import Logger = require('./logger-util');
-import RequestUtil = require('./request-util');
-import DomainUtil = require('./domain-util');
+import type WebView from '../components/webview';
+import backoff from 'backoff';
+import request from 'request';
+import Logger from './logger-util';
+import * as RequestUtil from './request-util';
+import * as DomainUtil from './domain-util';
 
 const logger = new Logger({
-	file: `domain-util.log`,
+	file: 'domain-util.log',
 	timestamp: true
 });
 
-class ReconnectUtil {
-	// TODO: TypeScript - Figure out how to annotate webview
-	// it should be WebView; maybe make it a generic so we can
-	// pass the class from main.ts
-	webview: any;
+export default class ReconnectUtil {
+	webview: WebView;
 	url: string;
 	alreadyReloaded: boolean;
-	fibonacciBackoff: any;
+	fibonacciBackoff: backoff.Backoff;
 
-	constructor(webview: any) {
+	constructor(webview: WebView) {
 		this.webview = webview;
 		this.url = webview.props.url;
 		this.alreadyReloaded = false;
@@ -34,69 +32,61 @@ class ReconnectUtil {
 		});
 	}
 
-	isOnline(): Promise<boolean> {
+	async isOnline(): Promise<boolean> {
 		return new Promise(resolve => {
 			try {
 				const ignoreCerts = DomainUtil.shouldIgnoreCerts(this.url);
 				if (ignoreCerts === null) {
 					return;
 				}
+
 				request(
 					{
 						url: `${this.url}/static/favicon.ico`,
 						...RequestUtil.requestOptions(this.url, ignoreCerts)
 					},
-					(error: Error, response: any) => {
+					(error: Error, response: request.Response) => {
 						const isValidResponse =
 							!error && response.statusCode >= 200 && response.statusCode < 400;
 						resolve(isValidResponse);
 					}
 				);
-			} catch (err) {
-				logger.log(err);
+			} catch (error) {
+				logger.log(error);
 			}
 		});
 	}
 
 	pollInternetAndReload(): void {
 		this.fibonacciBackoff.backoff();
-		this.fibonacciBackoff.on('ready', () => {
-			this._checkAndReload().then(status => {
-				if (status) {
-					this.fibonacciBackoff.reset();
-				} else {
-					this.fibonacciBackoff.backoff();
-				}
-			});
-		});
-	}
-
-	// TODO: Make this a async function
-	_checkAndReload(): Promise<boolean> {
-		return new Promise(resolve => {
-			if (!this.alreadyReloaded) { // eslint-disable-line no-negated-condition
-				this.isOnline()
-					.then((online: boolean) => {
-						if (online) {
-							ipcRenderer.send('forward-message', 'reload-viewer');
-							logger.log('You\'re back online.');
-							return resolve(true);
-						}
-
-						logger.log('There is no internet connection, try checking network cables, modem and router.');
-						const errMsgHolder = document.querySelector('#description');
-						if (errMsgHolder) {
-							errMsgHolder.innerHTML = `
-										<div>Your internet connection doesn't seem to work properly!</div>
-										<div>Verify that it works and then click try again.</div>`;
-						}
-						return resolve(false);
-					});
+		this.fibonacciBackoff.on('ready', async () => {
+			if (await this._checkAndReload()) {
+				this.fibonacciBackoff.reset();
 			} else {
-				return resolve(true);
+				this.fibonacciBackoff.backoff();
 			}
 		});
 	}
-}
 
-export = ReconnectUtil;
+	async _checkAndReload(): Promise<boolean> {
+		if (this.alreadyReloaded) {
+			return true;
+		}
+
+		if (await this.isOnline()) {
+			ipcRenderer.send('forward-message', 'reload-viewer');
+			logger.log('You\'re back online.');
+			return true;
+		}
+
+		logger.log('There is no internet connection, try checking network cables, modem and router.');
+		const errorMessageHolder = document.querySelector('#description');
+		if (errorMessageHolder) {
+			errorMessageHolder.innerHTML = `
+						<div>Your internet connection doesn't seem to work properly!</div>
+						<div>Verify that it works and then click try again.</div>`;
+		}
+
+		return false;
+	}
+}

app/renderer/js/utils/request-util.ts

@@ -1,87 +1,71 @@
-import { remote } from 'electron';
+import {remote} from 'electron';
 
-import fs = require('fs');
-import path = require('path');
-import ConfigUtil = require('./config-util');
-import Logger = require('./logger-util');
-import ProxyUtil = require('./proxy-util');
-import CertificateUtil = require('./certificate-util');
-import SystemUtil = require('./system-util');
+import fs from 'fs';
+import path from 'path';
+import * as ConfigUtil from './config-util';
+import Logger from './logger-util';
+import * as ProxyUtil from './proxy-util';
+import * as CertificateUtil from './certificate-util';
+import * as SystemUtil from './system-util';
 
-const { app } = remote;
+const {app} = remote;
 
 const logger = new Logger({
-	file: `request-util.log`,
+	file: 'request-util.log',
 	timestamp: true
 });
 
-let instance: null | RequestUtil = null;
-
-// TODO: TypeScript - Use ProxyRule for the proxy property
-// we can do this now since we use export = ProxyUtil syntax
 interface RequestUtilResponse {
 	ca: string;
-	proxy: string | void | object;
+	proxy: string | void | ProxyUtil.ProxyRule;
 	ecdhCurve: 'auto';
 	headers: { 'User-Agent': string };
 	rejectUnauthorized: boolean;
 }
 
-class RequestUtil {
-	constructor() {
-		if (!instance) {
-			instance = this;
-		}
+// ignoreCerts parameter helps in fetching server icon and
+// other server details when user chooses to ignore certificate warnings
+export function requestOptions(domain: string, ignoreCerts: boolean): RequestUtilResponse {
+	domain = formatUrl(domain);
+	const certificate = CertificateUtil.getCertificate(
+		encodeURIComponent(domain)
+	);
 
-		return instance;
+	let certificateFile = null;
+	if (certificate?.includes('/')) {
+		// Certificate saved using old app version
+		certificateFile = certificate;
+	} else if (certificate) {
+		certificateFile = path.join(`${app.getPath('userData')}/certificates`, certificate);
 	}
 
-	// ignoreCerts parameter helps in fetching server icon and
-	// other server details when user chooses to ignore certificate warnings
-	requestOptions(domain: string, ignoreCerts: boolean): RequestUtilResponse {
-		domain = this.formatUrl(domain);
-		const certificate = CertificateUtil.getCertificate(
-			encodeURIComponent(domain)
-		);
-
-		let certificateFile = null;
-		if (certificate && certificate.includes('/')) {
-			// certificate saved using old app version
-			certificateFile = certificate;
-		} else if (certificate) {
-			certificateFile = path.join(`${app.getPath('userData')}/certificates`, certificate);
-		}
-
-		let certificateLocation = '';
-		if (certificate) {
-			// To handle case where certificate has been moved from the location in certificates.json
-			try {
-				certificateLocation = fs.readFileSync(certificateFile, 'utf8');
-			} catch (err) {
-				logger.warn(`Error while trying to get certificate: ${err}`);
-			}
-		}
-		const proxyEnabled = ConfigUtil.getConfigItem('useManualProxy') || ConfigUtil.getConfigItem('useSystemProxy');
-		// If certificate for the domain exists add it as a ca key in the request's parameter else consider only domain as the parameter for request
-		// Add proxy as a parameter if it is being used.
-		return {
-			ca: certificateLocation ? certificateLocation : '',
-			proxy: proxyEnabled ? ProxyUtil.getProxy(domain) : '',
-			ecdhCurve: 'auto',
-			headers: { 'User-Agent': SystemUtil.getUserAgent() },
-			rejectUnauthorized: !ignoreCerts
-		};
-	}
-
-	formatUrl(domain: string): string {
-		const hasPrefix = domain.startsWith('http', 0);
-		if (hasPrefix) {
-			return domain;
-		} else {
-			return domain.includes('localhost:') ? `http://${domain}` : `https://${domain}`;
+	let certificateLocation = '';
+	if (certificate) {
+		// To handle case where certificate has been moved from the location in certificates.json
+		try {
+			certificateLocation = fs.readFileSync(certificateFile, 'utf8');
+		} catch (error) {
+			logger.warn('Error while trying to get certificate:', error);
 		}
 	}
+
+	const proxyEnabled = ConfigUtil.getConfigItem('useManualProxy') || ConfigUtil.getConfigItem('useSystemProxy');
+	// If certificate for the domain exists add it as a ca key in the request's parameter else consider only domain as the parameter for request
+	// Add proxy as a parameter if it is being used.
+	return {
+		ca: certificateLocation ? certificateLocation : '',
+		proxy: proxyEnabled ? ProxyUtil.getProxy(domain) : '',
+		ecdhCurve: 'auto',
+		headers: {'User-Agent': SystemUtil.getUserAgent()},
+		rejectUnauthorized: !ignoreCerts
+	};
 }
 
-const requestUtil = new RequestUtil();
-export = requestUtil;
+function formatUrl(domain: string): string {
+	const hasPrefix = domain.startsWith('http', 0);
+	if (hasPrefix) {
+		return domain;
+	}
+
+	return domain.includes('localhost:') ? `http://${domain}` : `https://${domain}`;
+}

app/renderer/js/utils/sentry-util.ts

@@ -1,21 +1,18 @@
-import { init } from '@sentry/electron';
+import {init} from '@sentry/electron';
 
-import isDev = require('electron-is-dev');
-import path = require('path');
-import dotenv = require('dotenv');
-dotenv.config({ path: path.resolve(__dirname, '/../../../../.env') });
+import isDev from 'electron-is-dev';
 
 export const sentryInit = (): void => {
 	if (!isDev) {
 		init({
-			dsn: process.env.SENTRY_DSN,
+			dsn: 'https://628dc2f2864243a08ead72e63f94c7b1@sentry.io/204668',
 			// We should ignore this error since it's harmless and we know the reason behind this
 			// This error mainly comes from the console logs.
 			// This is a temp solution until Sentry supports disabling the console logs
 			ignoreErrors: ['does not appear to be a valid Zulip server']
-			// sendTimeout: 30 // wait 30 seconds before considering the sending capture to have failed, default is 1 second
+			/// sendTimeout: 30 // wait 30 seconds before considering the sending capture to have failed, default is 1 second
 		});
 	}
 };
 
-export { captureException } from '@sentry/electron';
+export {captureException} from '@sentry/electron';

app/renderer/js/utils/system-util.ts

@@ -1,64 +1,39 @@
-'use strict';
-import { remote } from 'electron';
+import {ipcRenderer} from 'electron';
 
-import os = require('os');
-import ConfigUtil = require('./config-util');
+import os from 'os';
 
-const { app } = remote;
-let instance: null | SystemUtil = null;
+export const connectivityERR: string[] = [
+	'ERR_INTERNET_DISCONNECTED',
+	'ERR_PROXY_CONNECTION_FAILED',
+	'ERR_CONNECTION_RESET',
+	'ERR_NOT_CONNECTED',
+	'ERR_NAME_NOT_RESOLVED',
+	'ERR_NETWORK_CHANGED'
+];
 
-class SystemUtil {
-	connectivityERR: string[];
+const userAgent = ipcRenderer.sendSync('fetch-user-agent');
 
-	userAgent: string | null;
+export function getOS(): string {
+	const platform = os.platform();
+	if (platform === 'darwin') {
+		return 'Mac';
+	}
 
-	constructor() {
-		if (instance) {
-			return instance;
-		} else {
-			instance = this;
+	if (platform === 'linux') {
+		return 'Linux';
+	}
+
+	if (platform === 'win32') {
+		if (Number.parseFloat(os.release()) < 6.2) {
+			return 'Windows 7';
 		}
 
-		this.connectivityERR = [
-			'ERR_INTERNET_DISCONNECTED',
-			'ERR_PROXY_CONNECTION_FAILED',
-			'ERR_CONNECTION_RESET',
-			'ERR_NOT_CONNECTED',
-			'ERR_NAME_NOT_RESOLVED',
-			'ERR_NETWORK_CHANGED'
-		];
-		this.userAgent = null;
-
-		return instance;
+		return 'Windows 10';
 	}
 
-	getOS(): string {
-		const platform = os.platform();
-		if (platform === 'darwin') {
-			return 'Mac';
-		} else if (platform === 'linux') {
-			return 'Linux';
-		} else if (platform === 'win32') {
-			if (parseFloat(os.release()) < 6.2) {
-				return 'Windows 7';
-			} else {
-				return 'Windows 10';
-			}
-		} else {
-			return '';
-		}
-	}
-
-	setUserAgent(webViewUserAgent: string): void {
-		this.userAgent = `ZulipElectron/${app.getVersion()} ${webViewUserAgent}`;
-	}
-
-	getUserAgent(): string | null {
-		if (!this.userAgent) {
-			this.setUserAgent(ConfigUtil.getConfigItem('userAgent', null));
-		}
-		return this.userAgent;
-	}
+	return '';
 }
 
-export = new SystemUtil();
+export function getUserAgent(): string {
+	return userAgent;
+}

app/renderer/js/utils/translation-util.ts

@@ -1,35 +1,15 @@
-'use strict';
+import path from 'path';
+import i18n from 'i18n';
+import * as ConfigUtil from './config-util';
 
-import path = require('path');
-import electron = require('electron');
-import i18n = require('i18n');
+i18n.configure({
+	directory: path.join(__dirname, '../../../translations/')
+});
 
-let instance: TranslationUtil = null;
-let app: Electron.App = null;
+/* Fetches the current appLocale from settings.json */
+const appLocale = ConfigUtil.getConfigItem('appLanguage');
 
-/* To make the util runnable in both main and renderer process */
-if (process.type === 'renderer') {
-	app = electron.remote.app;
-} else {
-	app = electron.app;
+/* If no locale present in the json, en is set default */
+export function __(phrase: string): string {
+	return i18n.__({phrase, locale: appLocale ? appLocale : 'en'});
 }
-
-class TranslationUtil {
-	constructor() {
-		if (instance) {
-			return this;
-		}
-
-		instance = this;
-		i18n.configure({
-			directory: path.join(__dirname, '../../../translations/'),
-			register: this
-		});
-	}
-
-	__(phrase: string): string {
-		return i18n.__({ phrase, locale: app.getLocale() ? app.getLocale() : 'en' });
-	}
-}
-
-export = new TranslationUtil();

app/renderer/network.html

@@ -23,7 +23,4 @@
             </div>
         </div>
     </body>
-    <script>var exports = {};</script>
-    <script src="js/preload.js"></script>
-    <script>require('./js/shared/preventdrag.js')</script>
 </html>

app/resources/messages.ts

@@ -3,50 +3,47 @@ interface DialogBoxError {
 	content: string;
 }
 
-class Messages {
-	invalidZulipServerError(domain: string): string {
-		return `${domain} does not appear to be a valid Zulip server. Make sure that
-			\n • You can connect to that URL in a web browser.\
-			\n • If you need a proxy to connect to the Internet, that you've configured your proxy in the Network settings.\
-			\n • It's a Zulip server. (The oldest supported version is 1.6).\
-			\n • The server has a valid certificate. (You can add custom certificates in Settings > Organizations). \
-			\n • The SSL is correctly configured for the certificate. Check out the SSL troubleshooting guide -
-			\n https://zulip.readthedocs.io/en/stable/production/ssl-certificates.html`;
-	}
-
-	noOrgsError(domain: string): string {
-		return `${domain} does not have any organizations added.\
-		\nPlease contact your server administrator.`;
-	}
-
-	certErrorMessage(domain: string, error: string): string {
-		return `Do you trust certificate from ${domain}? \n ${error}`;
-	}
-
-	certErrorDetail(): string {
-		return `The organization you're connecting to is either someone impersonating the Zulip server you entered, or the server you're trying to connect to is configured in an insecure way.
-		\nIf you have a valid certificate please add it from Settings>Organizations and try to add the organization again.
-		\nUnless you have a good reason to believe otherwise, you should not proceed.
-		\nYou can click here if you'd like to proceed with the connection.`;
-	}
-
-	enterpriseOrgError(length: number, domains: string[]): DialogBoxError {
-		let domainList = '';
-		for (const domain of domains) {
-			domainList += `• ${domain}\n`;
-		}
-		return {
-			title: `Could not add the following ${length === 1 ? `organization` : `organizations`}`,
-			content: `${domainList}\nPlease contact your system administrator.`
-		};
-	}
-
-	orgRemovalError(url: string): DialogBoxError {
-		return {
-			title: `Removing ${url} is a restricted operation.`,
-			content: `Please contact your system administrator.`
-		};
-	}
+export function invalidZulipServerError(domain: string): string {
+	return `${domain} does not appear to be a valid Zulip server. Make sure that
+		\n • You can connect to that URL in a web browser.\
+		\n • If you need a proxy to connect to the Internet, that you've configured your proxy in the Network settings.\
+		\n • It's a Zulip server. (The oldest supported version is 1.6).\
+		\n • The server has a valid certificate. (You can add custom certificates in Settings > Organizations). \
+		\n • The SSL is correctly configured for the certificate. Check out the SSL troubleshooting guide -
+		\n https://zulip.readthedocs.io/en/stable/production/ssl-certificates.html`;
 }
 
-export = new Messages();
+export function noOrgsError(domain: string): string {
+	return `${domain} does not have any organizations added.\
+	\nPlease contact your server administrator.`;
+}
+
+export function certErrorMessage(domain: string, error: string): string {
+	return `Do you trust certificate from ${domain}? \n ${error}`;
+}
+
+export function certErrorDetail(): string {
+	return `The organization you're connecting to is either someone impersonating the Zulip server you entered, or the server you're trying to connect to is configured in an insecure way.
+	\nIf you have a valid certificate please add it from Settings>Organizations and try to add the organization again.
+	\nUnless you have a good reason to believe otherwise, you should not proceed.
+	\nYou can click here if you'd like to proceed with the connection.`;
+}
+
+export function enterpriseOrgError(length: number, domains: string[]): DialogBoxError {
+	let domainList = '';
+	for (const domain of domains) {
+		domainList += `• ${domain}\n`;
+	}
+
+	return {
+		title: `Could not add the following ${length === 1 ? 'organization' : 'organizations'}`,
+		content: `${domainList}\nPlease contact your system administrator.`
+	};
+}
+
+export function orgRemovalError(url: string): DialogBoxError {
+	return {
+		title: `Removing ${url} is a restricted operation.`,
+		content: 'Please contact your system administrator.'
+	};
+}

app/translations/en-GB.json

@@ -114,5 +114,9 @@
 	"Emoji & Symbols": "Emoji & Symbols",
 	"View Shortcuts": "View Shortcuts",
 	"Enter Full Screen": "Enter Full Screen",
-	"History Shortcuts": "History Shortcuts"
+	"History Shortcuts": "History Shortcuts",
+	"Quit when the window is closed": "Quit when the window is closed",
+	"File": "File",
+	"Network and Proxy Settings": "Network and Proxy Settings",
+	"Ask where to save files before downloading": "Ask where to save files before downloading"
 }

app/translations/en-US.json

@@ -104,5 +104,16 @@
 	"Edit Shortcuts": "Edit Shortcuts",
 	"View Shortcuts": "View Shortcuts",
 	"History Shortcuts": "History Shortcuts",
-	"Window Shortcuts": "Window Shortcuts"
-}
+	"Window Shortcuts": "Window Shortcuts",
+	"Quit when the window is closed": "Quit when the window is closed",
+	"Force social login in app instead of browser": "Force social login in app instead of browser",
+	"Ask where to save files before downloading": "Ask where to save files before downloading",
+	"Add a Zulip organization": "Add a Zulip organization",
+	"Connect": "Connect",
+	"OR": "OR",
+	"Create a new organization": "Create a new organization",
+	"Network and Proxy Settings": "Network and Proxy Settings",
+	"YES": "YES",
+	"NO": "NO",
+	"Are you sure you want to disconnect this organization?": "Are you sure you want to disconnect this organization?"
+}

app/translations/en.json

@@ -114,5 +114,6 @@
 	"Zulip Help": "Zulip Help",
 	"keyboard shortcuts": "keyboard shortcuts",
 	"script": "script",
-	"Quit when the window is closed": "Quit when the window is closed"
+	"Quit when the window is closed": "Quit when the window is closed",
+	"Ask where to save files before downloading": "Ask where to save files before downloading"
 }

app/translations/supported-locales.json

@@ -0,0 +1,23 @@
+{
+    "bg": "Bulgarian",
+    "cs": "Czech",
+    "de": "Deutsch",
+    "en-GB": "English (UK)",
+    "en-US": "English (US)",
+    "en": "English",
+    "es": "Español",
+    "fr": "French",
+    "hi": "Hindi",
+    "hu": "Hungarian",
+    "id": "Indonesian",
+    "ja": "Japanese",
+    "ko": "Korean",
+    "ml": "Malayalam",
+    "nl": "Dutch",
+    "pl": "Polish",
+    "pt": "Portuguese",
+    "ru": "Russian",
+    "sr": "Macedonian",
+    "ta": "Tamil",
+    "tr": "Turkish"
+}

appveyor.yml

@@ -5,17 +5,16 @@ platform:
 os: Previous Visual Studio 2015
 
 cache:
-  - node_modules
+  - node_modules -> appveyor.yml
 
 install:
-  - ps: Install-Product node 8 x64
+  - ps: Install-Product node 10 x64
   - git reset --hard HEAD
   - npm install npm -g
   - node --version
   - npm --version
   - python --version
-  - npm install
-  - npm install -g gulp
+  - npm ci
 
 build: off
 

changelog.md

@@ -2,6 +2,94 @@
 
 All notable changes to the Zulip desktop app are documented in this file.
 
+### v5.2.0 --2020-05-04
+
+**Security fixes**:
+* CVE-2020-12637: Do not ignore certificate errors in webviews unless the (unsupported, deprecated) `ignoreCerts` option is enabled.
+
+**Fixes**:
+* Avoid opening the file chooser dialog twice when downloading a file.
+
+**New features**:
+* Provide clipboard decryption helper for use in new social login flow.
+
+**Dependencies**:
+* Upgrade all dependencies, including Electron 8.2.5.
+
+### v5.1.0 --2020-04-29
+
+**Fixes**:
+* macOS: If the app is in foreground, the app will no longer hide upon clicking on dock again.
+* Synchronise debian scripts with electron-builder 22.4.1, thus fixing SUID sandbox binary issues.
+* Dock icon on macOS used to be larger than the other applications, which is now updated to the appropriate size.
+* Upon catching error in updating the server icon, the app will log the error and make a sentry report instead of triggering user-facing network error
+
+**New features**:
+* User can now set application language without changing the language on their operating system.
+
+**Dependencies**:
+* Upgrade all dependencies, including Electron 8.2.3.
+
+### v5.0.0 --2020-03-30
+
+**Security fixes**:
+* CVE-2020-10856: Enable Electron context isolation. (Reported by Matt Austin.)
+* CVE-2020-10857: Fix unsafe use of `shell.openExternal`/`shell.openItem`. (Reported by Matt Austin.)
+  * Downloaded files will no longer be opened directly; the previous option to show downloaded files in the file manager is now always on.
+* CVE-2020-10858: Add permission request handler to guard against audio/video recording by a malicious server. (Reported by Matt Austin.)
+
+**New features**:
+* Add an option to prompt for the location to save each downloaded file.
+
+**Fixes**:
+* Fix automatic launching at startup.
+* Fix Undo and Redo functionality on macOS.
+
+**Dependencies**:
+* Upgrade all dependencies, including Electron 8.0.3.
+* Remove `assert`, `cp-file`, `dotenv`, `electron-debug`, and `wurl`.
+
+**Deprecations**:
+* Since Electron upstream has discontinued support for 32-bit Linux, we will only provide 32-bit Linux builds on a best effort basis, and they will likely be removed in a future release.
+
+### v4.0.3 --2020-02-29
+
+**Security fixes**:
+* CVE-2020-9443: Do not disable web security in the Electron webview. (Reported by Matt Austin.)
+
+### v4.0.2-beta --2019-11-13
+
+**New features**:
+* Add support for MSI installers.
+* Show badge count on Linux.
+* Sync system presence info to web app.
+* Add option to open notification settings from the context menu of organization icons in the sidebar. 
+* Tackle network issues with each Zulip organization independently. 
+* Add option to quit on closing the window.
+* Make certificate location dynamic.
+* Add option to specify network settings when adding a new organization.
+
+**Enhancements**:
+* Load last active tab before others, speeding up user experience and eliminating flashing of server icons. 
+* Improve UX for notification settings.
+* Set User-Agent from the main process for communication with the Zulip API.
+* Add SSL troubleshooting guide in error message when adding an organization fails.
+
+**Fixes**:
+* Fix translations for `ru` locales.
+* Fix trailing brackets in settings page. 
+* Fix broken icon issue faced by the snap package on Linux. 
+* Reactivate `network.js` script.
+* Enable notarization for macOS Catalina. 
+
+**Documentation**:
+* Document enterprise configuration features. 
+* Update the Electron tutorial guide. 
+* Explicitly address where to report bugs in `README.md`. 
+* Fix typo in the link to server/webapp repository in `README.md`. 
+* Add documentation for translation.
+
+
 ### v4.0.0 --2019-08-08
 
 **New features**:

development.md

@@ -9,7 +9,7 @@ To build and run the app from source, you'll need the following:
 
 * [Git](http://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
   * Use our [Git Guide](https://zulip.readthedocs.io/en/latest/git/setup.html) to get started with Git and GitHub.
-* [Node.js](https://nodejs.org) >= v6.9.0
+* [Node.js](https://nodejs.org) >= v10.16.3
   * [NPM](https://www.npmjs.com/get-npm) and
     [node-gyp](https://github.com/nodejs/node-gyp#installation),
     if they don't come bundled with your Node.js installation
@@ -111,4 +111,4 @@ operating system you're running on:
 To generate all three types of files, you will need all three operating
 systems.
 
-The output distributable packages appear in the `dist/` directory.
+The output distributable packages appear in the `dist/` directory.

gulpfile.js

@@ -5,14 +5,14 @@ const electron = require('electron-connect').server.create({
 });
 const tape = require('gulp-tape');
 const tapColorize = require('tap-colorize');
-const ts = require("gulp-typescript");
-const tsProject = ts.createProject("tsconfig.json");
+const ts = require('gulp-typescript');
+const tsProject = ts.createProject('tsconfig.json');
 
 const glob = require('glob');
-const { execSync } = require('child_process');
+const {execSync} = require('child_process');
 
 const baseFilePattern = 'app/+(main|renderer)/**/*';
-const globOptions = { cwd: __dirname };
+const globOptions = {cwd: __dirname};
 const jsFiles = glob.sync(baseFilePattern + '.js', globOptions);
 const tsFiles = glob.sync(baseFilePattern + '.ts', globOptions);
 if (jsFiles.length !== tsFiles.length) {
@@ -21,18 +21,18 @@ if (jsFiles.length !== tsFiles.length) {
 	execSync(`${npx} tsc`);
 }
 
-gulp.task("compile", function () {
-    return tsProject.src()
-        .pipe(tsProject())
-        .js.pipe(gulp.dest("app"));
+gulp.task('compile', () => {
+	return tsProject.src()
+		.pipe(tsProject())
+		.js.pipe(gulp.dest('app'));
 });
 
 gulp.task('dev', () => {
-  // Start browser process
+	// Start browser process
 	electron.start();
-  // Restart browser process
+	// Restart browser process
 	gulp.watch('app/main/*.ts', gulp.series('compile', 'restart:browser'));
-  // Reload renderer process
+	// Reload renderer process
 	gulp.watch('app/renderer/css/*.css', gulp.series('reload:renderer'));
 	gulp.watch('app/renderer/*.html', gulp.series('reload:renderer'));
 	gulp.watch('app/renderer/js/**/*.ts', gulp.series('compile', 'reload:renderer'));
@@ -45,16 +45,16 @@ gulp.task('restart:browser', done => {
 });
 
 gulp.task('reload:renderer', done => {
-  // Reload renderer process
+	// Reload renderer process
 	electron.reload();
 	done();
 });
 
 gulp.task('test-e2e', () => {
 	return gulp.src('tests/*.js')
-	.pipe(tape({
-		reporter: tapColorize()
-	}));
+		.pipe(tape({
+			reporter: tapColorize()
+		}));
 });
 
 gulp.task('default', gulp.parallel('dev', 'test-e2e'));

package.json

@@ -1,7 +1,7 @@
 {
   "name": "zulip",
   "productName": "Zulip",
-  "version": "4.0.2-beta",
+  "version": "5.2.0",
   "main": "./app/main",
   "description": "Zulip Desktop App",
   "license": "Apache-2.0",
@@ -18,25 +18,24 @@
     "url": "https://github.com/zulip/zulip-desktop/issues"
   },
   "engines": {
-    "node": ">=6.0.0"
+    "node": ">=10.0.0"
   },
   "scripts": {
-    "start": "node tools/run-dev",
-    "clean-ts-files": "git clean app/*.js -xf",
+    "start": "tsc && electron .",
+    "clean-ts-files": "git clean app/*.js -e node_modules -xf",
     "watch-ts": "tsc -w",
     "reinstall": "node ./tools/reinstall-node-modules.js",
     "postinstall": "electron-builder install-app-deps",
     "lint-css": "stylelint app/renderer/css/*.css",
     "lint-html": "./node_modules/.bin/htmlhint \"app/renderer/*.html\" ",
     "lint-js": "xo",
-    "test": "npm run lint-html && npm run lint-css && npm run lint-js",
+    "test": "tsc --noEmit && npm run lint-html && npm run lint-css && npm run lint-js",
     "test-e2e": "gulp test-e2e",
     "compile": "gulp compile",
     "dev": "gulp dev && npm test",
     "pack": "tsc && electron-builder --dir",
     "dist": "tsc && electron-builder",
     "mas": "tsc && electron-builder --mac mas",
-    "travis": "cd ./scripts && ./travis-build-test.sh",
     "build-locales": "node tools/locale-helper"
   },
   "pre-commit": [
@@ -50,9 +49,8 @@
       "**/*.node"
     ],
     "files": [
-      "**/*",
-      "!docs${/*}",
-      "!node_modules/@paulcbetts/cld/deps/cld${/*}"
+      "app/**/*",
+      "!**/node_modules/cld/deps/cld"
     ],
     "copyright": "©2019 Kandra Labs, Inc.",
     "mac": {
@@ -143,97 +141,106 @@
     "Desktop app",
     "InstantMessaging"
   ],
+  "dependencies": {
+    "@electron-elements/send-feedback": "^1.0.8",
+    "@sentry/electron": "^1.3.0",
+    "adm-zip": "^0.4.14",
+    "auto-launch": "^5.0.5",
+    "backoff": "^2.5.0",
+    "electron-is-dev": "^1.2.0",
+    "electron-log": "^4.1.2",
+    "electron-spellchecker": "^2.2.1",
+    "electron-updater": "^4.3.1",
+    "electron-window-state": "^5.0.3",
+    "escape-html": "^1.0.3",
+    "fs-extra": "^9.0.0",
+    "i18n": "^0.9.1",
+    "node-json-db": "^1.1.0",
+    "request": "^2.88.2",
+    "rxjs": "^5.5.12",
+    "semver": "^7.3.2"
+  },
+  "optionalDependencies": {
+    "node-mac-notifier": "^1.1.0"
+  },
   "devDependencies": {
-    "@types/adm-zip": "^0.4.32",
-    "@types/dotenv": "6.1.1",
-    "@typescript-eslint/eslint-plugin": "1.10.2",
-    "@typescript-eslint/parser": "1.10.2",
-    "@vitalets/google-translate-api": "2.8.0",
-    "assert": "1.4.1",
-    "cp-file": "5.0.0",
-    "devtron": "1.4.0",
-    "electron": "3.1.10",
-    "electron-builder": "20.43.0",
-    "electron-connect": "0.6.2",
-    "electron-debug": "1.4.0",
-    "electron-notarize": "0.2.0",
-    "eslint-config-xo-typescript": "0.14.0",
-    "fs-extra": "8.1.0",
-    "gulp": "4.0.0",
-    "gulp-tape": "0.0.9",
-    "gulp-typescript": "5.0.1",
-    "htmlhint": "0.11.0",
-    "is-ci": "1.0.10",
-    "nodemon": "1.14.11",
-    "pre-commit": "1.2.2",
-    "spectron": "5.0.0",
-    "stylelint": "9.10.1",
-    "tap-colorize": "1.2.0",
-    "tape": "4.8.0",
-    "typescript": "3.5.2",
-    "xo": "0.24.0"
+    "@types/adm-zip": "^0.4.33",
+    "@types/auto-launch": "^5.0.1",
+    "@types/backoff": "^2.5.1",
+    "@types/electron-spellchecker": "^1.1.2",
+    "@types/escape-html": "0.0.20",
+    "@types/fs-extra": "^8.1.0",
+    "@types/i18n": "^0.8.6",
+    "@types/node": "^13.13.4",
+    "@types/request": "^2.48.4",
+    "@types/requestidlecallback": "^0.3.1",
+    "@typescript-eslint/eslint-plugin": "^2.30.0",
+    "@typescript-eslint/parser": "^2.30.0",
+    "@vitalets/google-translate-api": "^3.0.0",
+    "devtron": "^1.4.0",
+    "dotenv": "^8.2.0",
+    "electron": "^8.2.5",
+    "electron-builder": "^22.6.0",
+    "electron-connect": "^0.6.3",
+    "electron-notarize": "^0.3.0",
+    "eslint-config-xo-typescript": "^0.28.0",
+    "glob": "^7.1.6",
+    "gulp": "^4.0.2",
+    "gulp-tape": "^1.0.0",
+    "gulp-typescript": "^6.0.0-alpha.1",
+    "htmlhint": "^0.11.0",
+    "nodemon": "^2.0.3",
+    "pre-commit": "^1.2.2",
+    "rimraf": "^3.0.2",
+    "spectron": "^10.0.1",
+    "stylelint": "^13.3.3",
+    "tap-colorize": "^1.2.0",
+    "tape": "^5.0.0",
+    "typescript": "^3.8.3",
+    "xo": "^0.30.0"
   },
   "xo": {
-    "extends": "xo-typescript",
-    "extensions": [
-      "ts"
-    ],
-    "parserOptions": {
-      "ecmaVersion": 6,
-      "sourceType": "module",
-      "ecmaFeatures": {
-        "globalReturn": true,
-        "modules": true
-      }
-    },
-    "esnext": true,
-    "overrides": [
-      {
-        "files": "app/**/*.ts",
-        "rules": {
-          "max-lines": [
-            "warn",
-            {
-              "max": 800,
-              "skipBlankLines": true,
-              "skipComments": true
-            }
-          ],
-          "no-warning-comments": 0,
-          "object-curly-spacing": 0,
-          "capitalized-comments": 0,
-          "no-else-return": 0,
-          "no-path-concat": 0,
-          "no-alert": 0,
-          "guard-for-in": 0,
-          "prefer-promise-reject-errors": 0,
-          "import/no-unresolved": 0,
-          "import/no-extraneous-dependencies": 0,
-          "no-prototype-builtins": 0,
-          "lines-between-class-members": 0,
-          "padding-line-between-statements": 0,
-          "quotes": 0,
-          "unicorn/catch-error-name": 0,
-          "unicorn/no-console-spaces": 0,
-          "node/no-deprecated-api": 0,
-          "@typescript-eslint/member-ordering": "never",
-          "@typescript-eslint/restrict-plus-operands": "never",
-          "import/default": 0,
-          "@typescript-eslint/no-unused-vars": 0
+    "rules": {
+      "@typescript-eslint/no-dynamic-delete": "off",
+      "@typescript-eslint/prefer-readonly-parameter-types": "off",
+      "import/unambiguous": "error",
+      "max-lines": [
+        "warn",
+        {
+          "max": 900,
+          "skipBlankLines": true,
+          "skipComments": true
         }
-      }
-    ],
-    "ignore": [
-      "tests/*.js",
-      "tools/locale-helper/*.js",
-      "*/**/*.js",
-      "*.js",
-      "typings.d.ts"
-    ],
+      ],
+      "no-warning-comments": "off",
+      "strict": "error"
+    },
     "envs": [
       "node",
-      "browser",
-      "mocha"
+      "browser"
+    ],
+    "overrides": [
+      {
+        "files": [
+          "app/renderer/js/injected.ts",
+          "gulpfile.js",
+          "scripts/notarize.js",
+          "tests/**/*.js",
+          "tools/locale-helper/index.js",
+          "tools/reinstall-node-modules.js"
+        ],
+        "parserOptions": {
+          "sourceType": "script"
+        }
+      },
+      {
+        "files": [
+          "**/*.d.ts"
+        ],
+        "rules": {
+          "import/unambiguous": "off"
+        }
+      }
     ]
   }
 }

scripts/debian-add-repo.sh

@@ -3,8 +3,13 @@
 # This script runs when user install the debian package
 
 # Link to the binary
-ln -sf '/opt/${productFilename}/${executable}' '/usr/local/bin/${executable}';
-echo 'Successfully added /opt/${productFilename}/${executable} to /usr/local/bin/${executable}'
+ln -sf '/opt/${productFilename}/${executable}' '/usr/bin/${executable}'
+
+# SUID chrome-sandbox for Electron 5+
+chmod 4755 '/opt/${productFilename}/chrome-sandbox' || true
+
+update-mime-database /usr/share/mime || true
+update-desktop-database /usr/share/applications || true
 
 # Install apt repository source list if it does not exist
 if ! grep ^ /etc/apt/sources.list /etc/apt/sources.list.d/* | grep zulip.list; then

scripts/debian-uninstaller.sh

@@ -31,5 +31,4 @@ if [ -d $appDirectory ]; then
 fi
 
 # Delete the link to the binary
-echo 'Removing binary link'
-sudo rm -f '/usr/local/bin/${executable}';
+rm -f '/usr/bin/${executable}'

scripts/notarize.js

@@ -1,22 +1,24 @@
+'use strict';
 const path = require('path');
 const dotenv = require('dotenv');
 
-dotenv.config({ path: path.join(__dirname, '/../.env') });
+dotenv.config({path: path.join(__dirname, '/../.env')});
 
-const { notarize } = require('electron-notarize');
+const {notarize} = require('electron-notarize');
 
-exports.default = async function notarizing(context) {
-  const { electronPlatformName, appOutDir } = context;
-  if (electronPlatformName !== 'darwin') {
-    return;
-  }
+exports.default = async function (context) {
+	const {electronPlatformName, appOutDir} = context;
+	if (electronPlatformName !== 'darwin') {
+		return;
+	}
 
-  const appName = context.packager.appInfo.productFilename;
+	const appName = context.packager.appInfo.productFilename;
 
-  return await notarize({
-    appBundleId: 'org.zulip.zulip-electron',
-    appPath: `${appOutDir}/${appName}.app`,
-    appleId: process.env.APPLE_ID,
-    appleIdPassword: process.env.APPLE_ID_PASS,
-  });
+	return notarize({
+		appBundleId: 'org.zulip.zulip-electron',
+		appPath: `${appOutDir}/${appName}.app`,
+		appleId: process.env.APPLE_ID,
+		appleIdPassword: process.env.APPLE_ID_PASS,
+		ascProvider: process.env.ASC_PROVIDER // Team short name
+	});
 };

scripts/travis-build-test.sh

@@ -1,20 +0,0 @@
-#!/usr/bin/env bash
-
-# exit script if fails
-set -e;
-
-if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-    export {no_proxy,NO_PROXY}="127.0.0.1,localhost"
-    export DISPLAY=:99.0
-    sh -e /etc/init.d/xvfb start
-    sleep 3
-
-    echo 'Travis Screen Resolution:'
-    xdpyinfo | grep dimensions
-fi
-
-npm run test
-
-# if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-#     npm run test-e2e
-# fi

scripts/travis-xvfb.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-
-if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-    /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -ac -screen 0 1280x1024x16
-fi

tests/config.js

@@ -1,7 +1,7 @@
-const path = require('path')
+'use strict';
 
-const TEST_APP_PRODUCT_NAME = 'ZulipTest'
+const TEST_APP_PRODUCT_NAME = 'ZulipTest';
 
 module.exports = {
-  TEST_APP_PRODUCT_NAME
-}
+	TEST_APP_PRODUCT_NAME
+};

tests/e2e/package.json

@@ -1,183 +0,0 @@
-{
-    "name": "zulip",
-    "productName": "Zulip",
-    "version": "2.4.0",
-    "main": "../../app/main",
-    "description": "Zulip Desktop App",
-    "license": "Apache-2.0",
-    "copyright": "Kandra Labs, Inc.",
-    "author": {
-      "name": "Kandra Labs, Inc.",
-      "email": "support@zulipchat.com"
-    },
-    "repository": {
-      "type": "git",
-      "url": "https://github.com/zulip/zulip-electron.git"
-    },
-    "bugs": {
-      "url": "https://github.com/zulip/zulip-electron/issues"
-    },
-    "engines": {
-      "node": ">=6.0.0"
-    },
-    "scripts": {
-      "start": "electron app --disable-http-cache --no-electron-connect",
-      "reinstall": "node ./tools/reinstall-node-modules.js",
-      "postinstall": "electron-builder install-app-deps",
-      "test": "xo",
-      "test-e2e": "gulp test-e2e",
-      "dev": "gulp dev & nodemon --watch app/main --watch app/renderer --exec 'npm test' -e html,css,js",
-      "pack": "electron-builder --dir",
-      "dist": "electron-builder",
-      "mas": "electron-builder --mac mas",
-      "travis": "cd ./scripts && ./travis-build-test.sh",
-      "build-locales": "node tools/locale-helper"
-    },
-    "pre-commit": [
-      "test"
-    ],
-    "build": {
-      "appId": "org.zulip.zulip-electron",
-      "asar": true,
-      "files": [
-        "**/*",
-        "!docs${/*}",
-        "!node_modules/@paulcbetts/cld/deps/cld${/*}"
-      ],
-      "copyright": "©2017 Kandra Labs, Inc.",
-      "mac": {
-        "category": "public.app-category.productivity",
-        "artifactName": "${productName}-${version}-${arch}.${ext}"
-      },
-      "linux": {
-        "category": "Chat;GNOME;GTK;Network;InstantMessaging",
-        "packageCategory": "GNOME;GTK;Network;InstantMessaging",
-        "description": "Zulip Desktop Client for Linux",
-        "target": [
-          "deb",
-          "zip",
-          "AppImage",
-          "snap"
-        ],
-        "maintainer": "Akash Nimare <svnitakash@gmail.com>",
-        "artifactName": "${productName}-${version}-${arch}.${ext}"
-      },
-      "deb": {
-        "synopsis": "Zulip Desktop App",
-        "afterInstall": "./scripts/debian-add-repo.sh",
-        "afterRemove": "./scripts/debian-uninstaller.sh"
-      },
-      "snap": {
-        "synopsis": "Zulip Desktop App"
-      },
-      "dmg": {
-        "background": "build/appdmg.png",
-        "icon": "build/icon.icns",
-        "iconSize": 100,
-        "contents": [
-          {
-            "x": 380,
-            "y": 280,
-            "type": "link",
-            "path": "/Applications"
-          },
-          {
-            "x": 110,
-            "y": 280,
-            "type": "file"
-          }
-        ],
-        "window": {
-          "width": 500,
-          "height": 500
-        }
-      },
-      "win": {
-        "target": [
-          {
-            "target": "nsis-web",
-            "arch": [
-              "x64",
-              "ia32"
-            ]
-          }
-        ],
-        "icon": "build/icon.ico",
-        "publisherName": "Kandra Labs, Inc."
-      },
-      "nsis": {
-        "allowToChangeInstallationDirectory": true
-      }
-    },
-    "keywords": [
-      "Zulip",
-      "Group Chat app",
-      "electron-app",
-      "electron",
-      "Desktop app",
-      "InstantMessaging"
-    ],
-    "devDependencies": {
-      "assert": "1.4.1",
-      "cp-file": "^5.0.0",
-      "devtron": "1.4.0",
-      "electron": "3.0.10",
-      "electron-builder": "20.38.4",
-      "electron-connect": "0.6.2",
-      "electron-debug": "1.4.0",
-      "google-translate-api": "2.3.0",
-      "gulp": "^4.0.0",
-      "gulp-tape": "0.0.9",
-      "is-ci": "^1.0.10",
-      "nodemon": "^1.14.11",
-      "pre-commit": "1.2.2",
-      "spectron": "3.8.0",
-      "tap-colorize": "^1.2.0",
-      "tape": "^4.8.0",
-      "xo": "0.18.2"
-    },
-    "xo": {
-      "parserOptions": {
-        "sourceType": "script",
-        "ecmaFeatures": {
-          "globalReturn": true
-        }
-      },
-      "esnext": true,
-      "overrides": [
-        {
-          "files": "app*/**/*.js",
-          "rules": {
-            "max-lines": [
-              "warn",
-              {
-                "max": 600,
-                "skipBlankLines": true,
-                "skipComments": true
-              }
-            ],
-            "no-warning-comments": 0,
-            "object-curly-spacing": 0,
-            "capitalized-comments": 0,
-            "no-else-return": 0,
-            "no-path-concat": 0,
-            "no-alert": 0,
-            "guard-for-in": 0,
-            "prefer-promise-reject-errors": 0,
-            "import/no-unresolved": 0,
-            "import/no-extraneous-dependencies": 0,
-            "no-prototype-builtins": 0
-          }
-        }
-      ],
-      "ignore": [
-        "tests/*.js",
-        "tools/locale-helper/*.js"
-      ],
-      "envs": [
-        "node",
-        "browser",
-        "mocha"
-      ]
-    }
-  }

tests/index.js

@@ -1,13 +1,17 @@
-const test = require('tape')
-const setup = require('./setup')
+'use strict';
+const test = require('tape');
+const setup = require('./setup');
 
-test('app runs', function (t) {
-  t.timeoutAfter(10e3)
-  setup.resetTestDataDir()
-  const app = setup.createApp()
-  setup.waitForLoad(app, t)
-    .then(() => app.client.windowByIndex(1)) // focus on webview
-    .then(() => app.client.waitForExist('//*[@id="connect"]')) // id of the connect button
-    .then(() => setup.endTest(app, t),
-          (err) => setup.endTest(app, t, err || 'error'))
-})
+test('app runs', async t => {
+	t.timeoutAfter(10e3);
+	setup.resetTestDataDir();
+	const app = setup.createApp();
+	try {
+		await setup.waitForLoad(app, t);
+		await app.client.windowByIndex(1); // Focus on webview
+		await app.client.waitForExist('//*[@id="connect"]'); // Id of the connect button
+		await setup.endTest(app, t);
+	} catch (error) {
+		await setup.endTest(app, t, error || 'error');
+	}
+});

tests/setup.js

@@ -1,99 +1,96 @@
-const Application = require('spectron').Application
-const cpFile = require('cp-file')
-const fs = require('fs')
-const isCI = require('is-ci')
-const mkdirp = require('mkdirp')
-const path = require('path')
-const rimraf = require('rimraf')
+'use strict';
+const {Application} = require('spectron');
+const fs = require('fs');
+const path = require('path');
+const rimraf = require('rimraf');
 
-const config = require('./config')
+const config = require('./config');
 
 module.exports = {
-  createApp,
-  endTest,
-  waitForLoad,
-  wait,
-  resetTestDataDir
-}
+	createApp,
+	endTest,
+	waitForLoad,
+	wait,
+	resetTestDataDir
+};
 
 // Runs Zulip Desktop.
 // Returns a promise that resolves to a Spectron Application once the app has loaded.
 // Takes a Tape test. Makes some basic assertions to verify that the app loaded correctly.
-function createApp (t) {
-  generateTestAppPackageJson()
-  return new Application({
-    path: path.join(__dirname, '..', 'node_modules', '.bin',
-      'electron' + (process.platform === 'win32' ? '.cmd' : '')),
-    args: [path.join(__dirname)], // Ensure this dir has a package.json file with a 'main' entry piont
-    env: {NODE_ENV: 'test'},
-    waitTimeout: 10e3
-  })
+function createApp() {
+	generateTestAppPackageJson();
+	return new Application({
+		path: path.join(__dirname, '..', 'node_modules', '.bin',
+			'electron' + (process.platform === 'win32' ? '.cmd' : '')),
+		args: [path.join(__dirname)], // Ensure this dir has a package.json file with a 'main' entry piont
+		env: {NODE_ENV: 'test'},
+		waitTimeout: 10e3
+	});
 }
 
 // Generates package.json for test app
-// Reads app package.json and updates the productName to config.TEST_APP_PRODUCT_NAME 
+// Reads app package.json and updates the productName to config.TEST_APP_PRODUCT_NAME
 // We do this so that the app integration doesn't doesn't share the same appDataDir as the dev application
-function generateTestAppPackageJson () {
-  let packageJson = require(path.join(__dirname, '../package.json'))
-  packageJson.productName = config.TEST_APP_PRODUCT_NAME
-  packageJson.main = '../app/main'
+function generateTestAppPackageJson() {
+	const packageJson = require(path.join(__dirname, '../package.json'));
+	packageJson.productName = config.TEST_APP_PRODUCT_NAME;
+	packageJson.main = '../app/main';
 
-  const testPackageJsonPath = path.join(__dirname, 'package.json')
-  fs.writeFileSync(testPackageJsonPath, JSON.stringify(packageJson, null, ' '), 'utf-8')
+	const testPackageJsonPath = path.join(__dirname, 'package.json');
+	fs.writeFileSync(testPackageJsonPath, JSON.stringify(packageJson, null, ' '), 'utf-8');
 }
 
 // Starts the app, waits for it to load, returns a promise
-function waitForLoad (app, t, opts) {
-  if (!opts) opts = {}
-  return app.start().then(function () {
-    return app.client.waitUntilWindowLoaded()
-  })
-  .then(function() {
-    return app.client.pause(2000);
-  })
-  .then(function () {
-    return app.webContents.getTitle()
-  }).then(function (title) {
-    t.equal(title, 'Zulip', 'html title')
-  })
+async function waitForLoad(app, t, options) {
+	if (!options) {
+		options = {};
+	}
+
+	await app.start();
+	await app.client.waitUntilWindowLoaded();
+	await app.client.pause(2000);
+	const title = await app.webContents.getTitle();
+	t.equal(title, 'Zulip', 'html title');
 }
 
 // Returns a promise that resolves after 'ms' milliseconds. Default: 1 second
-function wait (ms) {
-  if (ms === undefined) ms = 1000 // Default: wait long enough for the UI to update
-  return new Promise(function (resolve, reject) {
-    setTimeout(resolve, ms)
-  })
+async function wait(ms) {
+	if (ms === undefined) {
+		ms = 1000;
+	} // Default: wait long enough for the UI to update
+
+	return new Promise((resolve => {
+		setTimeout(resolve, ms);
+	}));
 }
 
 // Quit the app, end the test, either in success (!err) or failure (err)
-function endTest (app, t, err) {
-  return app.stop().then(function () {
-    t.end(err)
-  })
+async function endTest(app, t, err) {
+	await app.stop();
+	t.end(err);
 }
 
-function getAppDataDir () {
-  let base
+function getAppDataDir() {
+	let base;
 
-  if (process.platform === 'darwin') {
-    base = path.join(process.env.HOME, 'Library', 'Application Support')
-  } else if (process.platform === 'linux') {
-    base = process.env.XDG_CONFIG_HOME ?
-      process.env.XDG_CONFIG_HOME : path.join(process.env.HOME, '.config')
-  } else if (process.platform === 'win32') {
-    base = process.env.APPDATA
-  } else {
-    console.log('Could not detect app data dir base. Exiting...')
-    process.exit(1)
-  }
-  console.log('Detected App Data Dir base:', base)
-  return path.join(base, config.TEST_APP_PRODUCT_NAME)
+	if (process.platform === 'darwin') {
+		base = path.join(process.env.HOME, 'Library', 'Application Support');
+	} else if (process.platform === 'linux') {
+		base = process.env.XDG_CONFIG_HOME ?
+			process.env.XDG_CONFIG_HOME : path.join(process.env.HOME, '.config');
+	} else if (process.platform === 'win32') {
+		base = process.env.APPDATA;
+	} else {
+		throw new Error('Could not detect app data dir base.');
+	}
+
+	console.log('Detected App Data Dir base:', base);
+	return path.join(base, config.TEST_APP_PRODUCT_NAME);
 }
 
 // Resets the test directory, containing domain.json, window-state.json, etc
-function resetTestDataDir () {
-  appDataDir = getAppDataDir()
-  rimraf.sync(appDataDir)
-  rimraf.sync(path.join(__dirname, 'package.json'))
+function resetTestDataDir() {
+	const appDataDir = getAppDataDir();
+	rimraf.sync(appDataDir);
+	rimraf.sync(path.join(__dirname, 'package.json'));
 }

tests/test-add-organization.js

@@ -1,19 +1,22 @@
-const test = require('tape')
-const setup = require('./setup')
-
-test('add-organization', function (t) {
-  t.timeoutAfter(50e3)
-  setup.resetTestDataDir()
-  const app = setup.createApp()
-  setup.waitForLoad(app, t)
-    .then(() => app.client.windowByIndex(1)) // focus on webview
-    .then(() => app.client.setValue('.setting-input-value', 'chat.zulip.org'))
-    .then(() => app.client.click('.server-save-action'))
-    .then(() => setup.wait(5000))
-    .then(() => app.client.windowByIndex(0)) // Switch focus back to main win
-    .then(() => app.client.windowByIndex(1)) // Switch focus back to org webview
-    .then(() => app.client.waitForExist('//*[@id="id_username"]'))
-    .then(() => setup.endTest(app, t),
-          (err) => setup.endTest(app, t, err || 'error'))
-})
+'use strict';
+const test = require('tape');
+const setup = require('./setup');
 
+test('add-organization', async t => {
+	t.timeoutAfter(50e3);
+	setup.resetTestDataDir();
+	const app = setup.createApp();
+	try {
+		await setup.waitForLoad(app, t);
+		await app.client.windowByIndex(1); // Focus on webview
+		await app.client.setValue('.setting-input-value', 'chat.zulip.org');
+		await app.client.click('#connect');
+		await setup.wait(5000);
+		await app.client.windowByIndex(0); // Switch focus back to main win
+		await app.client.windowByIndex(1); // Switch focus back to org webview
+		await app.client.waitForExist('//*[@id="id_username"]');
+		await setup.endTest(app, t);
+	} catch (error) {
+		await setup.endTest(app, t, error || 'error');
+	}
+});

tests/test-new-organization.js

@@ -1,17 +1,20 @@
-const test = require('tape')
-const setup = require('./setup')
+'use strict';
+const test = require('tape');
+const setup = require('./setup');
 
 // Create new org link should open in the default browser [WIP]
 
-test('new-org-link', function (t) {
-  t.timeoutAfter(50e3)
-  setup.resetTestDataDir()
-  const app = setup.createApp()
-  setup.waitForLoad(app, t)
-    .then(() => app.client.windowByIndex(1)) // focus on webview
-    .then(() => app.client.click('#open-create-org-link')) // Click on new org link button
-    .then(() => setup.wait(5000))
-    .then(() => setup.endTest(app, t),
-          (err) => setup.endTest(app, t, err || 'error'))
-})
-
+test('new-org-link', async t => {
+	t.timeoutAfter(50e3);
+	setup.resetTestDataDir();
+	const app = setup.createApp();
+	try {
+		await setup.waitForLoad(app, t);
+		await app.client.windowByIndex(1); // Focus on webview
+		await app.client.click('#open-create-org-link'); // Click on new org link button
+		await setup.wait(5000);
+		await setup.endTest(app, t);
+	} catch (error) {
+		await setup.endTest(app, t, error || 'error');
+	}
+});

tools/locale-helper/index.js

@@ -1,3 +1,4 @@
+'use strict';
 const translate = require('@vitalets/google-translate-api');
 const path = require('path');
 const fs = require('fs');
@@ -5,28 +6,30 @@ const fs = require('fs');
 const translationDir = path.resolve(__dirname, '../../app/translations');
 
 function writeJSON(file, data) {
-    const filePath = path.resolve(translationDir, file);
-    fs.writeFileSync(filePath, `${JSON.stringify(data, null, '\t')}\n`, 'utf8');
+	const filePath = path.resolve(translationDir, file);
+	fs.writeFileSync(filePath, `${JSON.stringify(data, null, '\t')}\n`, 'utf8');
 }
 
-const { phrases } = require('./locale-template');
-const supportedLocales = require('./supported-locales');
+const {phrases} = require('./locale-template');
+const supportedLocales = require('./supported-locales.json');
 
 phrases.sort();
-for (let locale in supportedLocales) {
-    console.log(`fetching translation for: ${supportedLocales[locale]} - ${locale}..`);
-    translate(phrases.join('\n'), { to: locale })
-        .then(res => {
-            const localeFile = `${locale}.json`;
-            const translatedText = res.text.split('\n');
-            const translationJSON = {};
-            phrases.forEach((phrase, index) => {
-               translationJSON[phrase] = translatedText[index];
-            });
+for (const [locale, name] of Object.entries(supportedLocales)) {
+	console.log(`fetching translation for: ${name} - ${locale}..`);
+	(async () => {
+		try {
+			const result = await translate(phrases.join('\n'), {to: locale});
+			const localeFile = `${locale}.json`;
+			const translatedText = result.text.split('\n');
+			const translationJSON = {};
+			phrases.forEach((phrase, index) => {
+				translationJSON[phrase] = translatedText[index];
+			});
 
-            writeJSON(localeFile, translationJSON);
-            console.log(`create: ${localeFile}`);
-        }).catch(err => {
-            console.error(err);
-        });
+			writeJSON(localeFile, translationJSON);
+			console.log(`create: ${localeFile}`);
+		} catch (error) {
+			console.error(error);
+		}
+	})();
 }

tools/locale-helper/supported-locales.json

@@ -1,4 +1,4 @@
-module.exports = {
+{
     "de": "Deutsch",
     "pl": "polski",
     "en": "English",
@@ -18,4 +18,4 @@ module.exports = {
     "es": "español",
     "ko": "한국어",
     "fr": "français"
-};
+}

tools/reinstall-node-modules

@@ -2,9 +2,8 @@
 set -e
 set -x
 
-echo "Removing node_modules and app/node_modules"
+echo "Removing node_modules"
 rm -rf node_modules
-rm -rf app/node_modules
 
 echo "node_modules removed reinstalling npm packages"
 npm i

tools/reinstall-node-modules.cmd

@@ -1,8 +1,7 @@
 @echo off
 
-echo "Removing node_modules and app/node_modules"
+echo "Removing node_modules"
 rmdir /s /q node_modules
-rmdir /s /q app/node_modules
 
 echo "node_modules removed reinstalling npm packages"
 npm i

tools/reinstall-node-modules.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 const {exec} = require('child_process');
 const path = require('path');