release: New release v5.9.2.

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

.editorconfig

@@ -1,16 +1,11 @@
 root = true
 
 [*]
-indent_style = tab
-indent_size = 4
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
 
-[{package.json,*.yml}]
+[{*.css,*.html,*.js,*.json,*.ts}]
 indent_style = space
 indent_size = 2
-
-[*.md]
-trim_trailing_whitespace = false

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+github: zulip
+patreon: zulip
+open_collective: zulip

.github/ISSUE_TEMPLATE.md

@@ -1,8 +0,0 @@
----
-<!-- Please Include: -->
-- **Operating System**:
-  - [ ] Windows
-  - [ ] Linux/Ubuntu
-  - [ ] macOS
-- **Clear steps to reproduce the issue**:
-- **Relevant error messages and/or screenshots**:

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,31 @@
+---
+name: Bug report
+about: Create a report to help us improve
+---
+
+**Describe the bug**
+
+<!-- A clear and concise description of what the bug is. -->
+
+**To Reproduce**
+
+<!-- Clear steps to reproduce the issue. -->
+
+**Expected behavior**
+
+<!-- A clear and concise description of what you expected to happen. -->
+
+**Screenshots**
+
+<!-- If applicable, add screenshots to help explain your problem. -->
+
+**Desktop (please complete the following information):**
+
+- Operating System:
+<!-- (Platform and Version) e.g. macOS 10.13.6 / Windows 10 (1803) / Ubuntu 18.04 x64 -->
+- Zulip Desktop Version:
+<!-- e.g. 5.2.0 -->
+
+**Additional context**
+
+<!-- Add any other context about the problem here. -->

.github/ISSUE_TEMPLATE/custom.md

@@ -0,0 +1,4 @@
+---
+name: Custom issue template
+about: Describe this issue template's purpose here.
+---

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+---
+
+**Problem Description**
+
+<!-- Please add a clear and concise description of what the problem is. -->
+
+**Proposed Solution**
+
+<!-- Describe the solution you'd like in a clear and concise manner -->
+
+**Describe alternatives you've considered**
+
+<!-- A clear and concise description of any alternative solutions or features you've considered. -->
+
+**Additional context**
+
+<!-- Add any other context or screenshots about the feature request here. -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,4 +1,5 @@
 ---
+
 <!--
 Remove the fields that are not appropriate
 Please include:
@@ -11,6 +12,7 @@ Please include:
 **Screenshots?**
 
 **You have tested this PR on:**
-  - [ ] Windows
+
-  - [ ] Linux/Ubuntu
+- [ ] Windows
-  - [ ] macOS
+- [ ] Linux/Ubuntu
+- [ ] macOS

.github/workflows/node.js.yml

@@ -0,0 +1,15 @@
+name: Node.js CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: npm ci
+      - run: npm test

.gitignore

@@ -4,6 +4,9 @@
 # npm cache directory
 .npm
 
+# transifexrc - if user prefers it to be in working tree
+.transifexrc
+
 # Compiled binary build directory
 dist/
 

.htmlhintrc

@@ -1,12 +1,7 @@
 {
-  "tagname-lowercase": true,
-  "attr-lowercase": true,
-  "attr-value-double-quotes": true,
   "attr-value-not-empty": false,
   "attr-no-duplication": true,
   "doctype-first": true,
-  "tag-pair": true,
-  "empty-tag-not-self-closed": true,
   "spec-char-escape": true,
   "id-unique": true,
   "src-not-empty": true,
@@ -17,7 +12,6 @@
   "style-disabled": false,
   "inline-style-disabled": false,
   "inline-script-disabled": false,
-  "space-tab-mixed-disabled": "space4",
   "id-class-ad-disabled": false,
   "href-abs-or-rel": false,
   "attr-unsafe-chars": true,

.mailmap

@@ -0,0 +1,5 @@
+Anders Kaseorg <anders@zulip.com> <anders@zulipchat.com>
+Rishi Gupta <rishig@zulip.com> <rishig@zulipchat.com>
+Rishi Gupta <rishig@zulip.com> <rishig@users.noreply.github.com>
+Tim Abbott <tabbott@zulip.com> <tabbott@zulipchat.com>
+Tim Abbott <tabbott@zulip.com> <tabbott@mit.edu>

.node-version

@@ -1 +0,0 @@
-6.9.4

.prettierignore

@@ -0,0 +1,3 @@
+/app/**/*.js
+/app/translations/*.json
+/dist

.stylelintrc

@@ -1,67 +1,12 @@
 {
+  "extends": ["stylelint-config-standard", "stylelint-config-prettier"],
   "rules": {
-        # Stylistic rules for CSS.
-        "function-comma-space-after": "always",
-        "function-comma-space-before": "never",
-        "function-max-empty-lines": 0,
-        "function-whitespace-after": "always",
-
-        "value-keyword-case": "lower",
-        "value-list-comma-newline-after": "always-multi-line",
-        "value-list-comma-space-after": "always-single-line",
-        "value-list-comma-space-before": "never",
-        "value-list-max-empty-lines": 0,
-
-        "unit-case": "lower",
-        "property-case": "lower",
-        "color-hex-case": "lower",
-
-        "declaration-bang-space-before": "always",
-        "declaration-colon-newline-after": "always-multi-line",
-        "declaration-colon-space-after": "always-single-line",
-        "declaration-colon-space-before": "never",
-        "declaration-block-semicolon-newline-after": "always",
-        "declaration-block-semicolon-space-before": "never",
-        "declaration-block-trailing-semicolon": "always",
-
-        "block-closing-brace-empty-line-before": "never",
-        "block-closing-brace-newline-after": "always",
-        "block-closing-brace-newline-before": "always",
-        "block-opening-brace-newline-after": "always",
-        "block-opening-brace-space-before": "always",
-
-        "selector-attribute-brackets-space-inside": "never",
-        "selector-attribute-operator-space-after": "never",
-        "selector-attribute-operator-space-before": "never",
-        "selector-combinator-space-after": "always",
-        "selector-combinator-space-before": "always",
-        "selector-descendant-combinator-no-non-space": true,
-        "selector-pseudo-class-parentheses-space-inside": "never",
-        "selector-pseudo-element-case": "lower",
-        "selector-pseudo-element-colon-notation": "double",
-        "selector-type-case": "lower",
-        "selector-list-comma-newline-after": "always",
-        "selector-list-comma-space-before": "never",
-
-        "media-feature-colon-space-after": "always",
-        "media-feature-colon-space-before": "never",
-        "media-feature-name-case": "lower",
-        "media-feature-parentheses-space-inside": "never",
-        "media-feature-range-operator-space-after": "always",
-        "media-feature-range-operator-space-before": "always",
-        "media-query-list-comma-newline-after": "always",
-        "media-query-list-comma-space-before": "never",
-
-        "at-rule-name-case": "lower",
-        "at-rule-name-space-after": "always",
-        "at-rule-semicolon-newline-after": "always",
-        "at-rule-semicolon-space-before": "never",
-
-        "comment-whitespace-inside": "always",
-        "indentation": 4,
-        
-        # Limit language features
-        "color-no-hex": true,
     "color-named": "never",
+    "color-no-hex": true,
+    "font-family-no-missing-generic-family-keyword": [
+      true,
+      {"ignoreFontFamilies": ["Material Icons"]}
+    ],
+    "selector-type-no-unknown": [true, {"ignoreTypes": ["webview"]}]
   }
 }

.travis.yml

@@ -1,37 +0,0 @@
-sudo: required
-dist: trusty
-
-os:
-- osx
-- linux
-
-addons:
-  apt:
-    packages:
-    - build-essential
-    - libxext-dev
-    - libxtst-dev
-    - libxkbfile-dev
-
-language: node_js
-node_js:
-- '10'
-- '12'
-
-before_install:
-  - ./scripts/travis-xvfb.sh
-  - npm install -g gulp
-  - npm ci
-
-cache:
-  directories:
-  - node_modules
-
-script:
-- npm run travis
-notifications:
-  webhooks:
-    urls:
-      - https://zulip.org/zulipbot/travis
-    on_success: always
-    on_failure: always

.tx/config

@@ -0,0 +1,9 @@
+[main]
+host = https://www.transifex.com
+
+[zulip.desktopjson]
+file_filter = app/translations/<lang>.json
+minimum_perc = 0
+source_file = app/translations/en.json
+source_lang = en
+type = KEYVALUEJSON

CONTRIBUTING.md

@@ -10,11 +10,12 @@ Zulip-Desktop app is built on top of [Electron](http://electron.atom.io/). If yo
 
 ## Community
 
-* The whole Zulip documentation, such as setting up a development environment, setting up with the Zulip webapp project, and testing, can be read [here](https://zulip.readthedocs.io).
+- The whole Zulip documentation, such as setting up a development environment, setting up with the Zulip webapp project, and testing, can be read [here](https://zulip.readthedocs.io).
 
-* If you have any questions regarding zulip-desktop, open an [issue](https://github.com/zulip/zulip-desktop/issues/new/) or ask it on [chat.zulip.org](https://chat.zulip.org/#narrow/stream/16-desktop).
+- If you have any questions regarding zulip-desktop, open an [issue](https://github.com/zulip/zulip-desktop/issues/new/) or ask it on [chat.zulip.org](https://chat.zulip.org/#narrow/stream/16-desktop).
 
 ## Issue
+
 Ensure the bug was not already reported by searching on GitHub under [issues](https://github.com/zulip/zulip-desktop/issues). If you're unable to find an open issue addressing the bug, open a [new issue](https://github.com/zulip/zulip-desktop/issues/new).
 
 The [zulipbot](https://github.com/zulip/zulipbot) helps to claim an issue by commenting the following in the comment section: "**@zulipbot** claim". **@zulipbot** will assign you to the issue and label the issue as **in progress**. For more details, check out [**@zulipbot**](https://github.com/zulip/zulipbot).
@@ -22,26 +23,29 @@ The [zulipbot](https://github.com/zulip/zulipbot) helps to claim an issue by com
 Please pay attention to the following points while opening an issue.
 
 ### Does it happen on web browsers? (especially Chrome)
+
 Zulip's desktop client is based on Electron, which integrates the Chrome engine within a standalone application.
 If the problem you encounter can be reproduced on web browsers, it may be an issue with [Zulip web app](https://github.com/zulip/zulip).
 
 ### Write detailed information
+
 Detailed information is very helpful to understand an issue.
 
 For example:
-* How to reproduce the issue, step-by-step.
-* The expected behavior (or what is wrong).
-* Screenshots for GUI issues.
-* The application version.
-* The operating system.
-* The Zulip-Desktop version.
 
+- How to reproduce the issue, step-by-step.
+- The expected behavior (or what is wrong).
+- Screenshots for GUI issues.
+- The application version.
+- The operating system.
+- The Zulip-Desktop version.
 
 ## Pull Requests
+
 Pull Requests are always welcome.
 
 1. When you edit the code, please run `npm run test` to check the formatting of your code before you `git commit`.
 2. Ensure the PR description clearly describes the problem and solution. It should include:
-   * The operating system on which you tested.
+   - The operating system on which you tested.
-   * The Zulip-Desktop version on which you tested.
+   - The Zulip-Desktop version on which you tested.
-   * The relevant issue number, if applicable.
+   - The relevant issue number, if applicable.

README.md

@@ -1,22 +1,26 @@
 # Zulip Desktop Client
-[![Build Status](https://travis-ci.org/zulip/zulip-desktop.svg?branch=master)](https://travis-ci.org/zulip/zulip-desktop)
+
-[![Windows Build Status](https://ci.appveyor.com/api/projects/status/github/zulip/zulip-desktop?branch=master&svg=true)](https://ci.appveyor.com/project/zulip/zulip-desktop/branch/master)
+[![Build Status](https://travis-ci.com/zulip/zulip-desktop.svg?branch=main)](https://travis-ci.com/github/zulip/zulip-desktop)
+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/github/zulip/zulip-desktop?branch=main&svg=true)](https://ci.appveyor.com/project/zulip/zulip-desktop/branch/main)
 [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo)
 [![project chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://chat.zulip.org)
 
 Desktop client for Zulip. Available for Mac, Linux, and Windows.
 
-<img src="http://i.imgur.com/ChzTq4F.png"/>
+![screenshot](https://i.imgur.com/s1o6TRA.png)
+![screenshot](https://i.imgur.com/vekKnW4.png)
 
 # Download
-Please see the [installation guide](https://zulipchat.com/help/desktop-app-install-guide).
+
+Please see the [installation guide](https://zulip.com/help/desktop-app-install-guide).
 
 # Features
-* Sign in to multiple organizations
+
-* Desktop notifications with inline reply
+- Sign in to multiple organizations
-* Tray/dock integration
+- Desktop notifications with inline reply
-* Multi-language spell checker
+- Tray/dock integration
-* Automatic updates
+- Multi-language spell checker
+- Automatic updates
 
 # Reporting issues
 
@@ -33,4 +37,5 @@ First, join us on the [Zulip community server](https://zulip.readthedocs.io/en/l
 Also see our [contribution guidelines](./CONTRIBUTING.md) and our [development guide](./development.md).
 
 # License
+
 Released under the [Apache-2.0](./LICENSE) license.

app/common/config-schemata.ts

@@ -0,0 +1,44 @@
+import * as z from "zod";
+
+export const dndSettingsSchemata = {
+  showNotification: z.boolean(),
+  silent: z.boolean(),
+  flashTaskbarOnMessage: z.boolean(),
+};
+
+export const configSchemata = {
+  ...dndSettingsSchemata,
+  appLanguage: z.string().nullable(),
+  autoHideMenubar: z.boolean(),
+  autoUpdate: z.boolean(),
+  badgeOption: z.boolean(),
+  betaUpdate: z.boolean(),
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  customCSS: z.string().or(z.literal(false)).nullable(),
+  dnd: z.boolean(),
+  dndPreviousSettings: z.object(dndSettingsSchemata).partial(),
+  dockBouncing: z.boolean(),
+  downloadsPath: z.string(),
+  enableSpellchecker: z.boolean(),
+  errorReporting: z.boolean(),
+  lastActiveTab: z.number(),
+  promptDownload: z.boolean(),
+  proxyBypass: z.string(),
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  proxyPAC: z.string(),
+  proxyRules: z.string(),
+  quitOnClose: z.boolean(),
+  showSidebar: z.boolean(),
+  spellcheckerLanguages: z.string().array().nullable(),
+  startAtLogin: z.boolean(),
+  startMinimized: z.boolean(),
+  trayIcon: z.boolean(),
+  useManualProxy: z.boolean(),
+  useProxy: z.boolean(),
+  useSystemProxy: z.boolean(),
+};
+
+export const enterpriseConfigSchemata = {
+  ...configSchemata,
+  presetOrganizations: z.string().array(),
+};

app/common/config-util.ts

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import * as Sentry from "@sentry/electron";
+import {JsonDB} from "node-json-db";
+import {DataError} from "node-json-db/dist/lib/Errors";
+import type * as z from "zod";
+
+import {configSchemata} from "./config-schemata";
+import * as EnterpriseUtil from "./enterprise-util";
+import Logger from "./logger-util";
+import {app, dialog} from "./remote";
+
+export type Config = {
+  [Key in keyof typeof configSchemata]: z.output<typeof configSchemata[Key]>;
+};
+
+const logger = new Logger({
+  file: "config-util.log",
+});
+
+let db: JsonDB;
+
+reloadDb();
+
+export function getConfigItem<Key extends keyof Config>(
+  key: Key,
+  defaultValue: Config[Key],
+): z.output<typeof configSchemata[Key]> {
+  try {
+    db.reload();
+  } catch (error: unknown) {
+    logger.error("Error while reloading settings.json: ");
+    logger.error(error);
+  }
+
+  try {
+    return configSchemata[key].parse(db.getObject<unknown>(`/${key}`));
+  } catch (error: unknown) {
+    if (!(error instanceof DataError)) throw error;
+    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: unknown) {
+    logger.error("Error while reloading settings.json: ");
+    logger.error(error);
+  }
+
+  return db.exists(`/${key}`);
+}
+
+export function setConfigItem<Key extends keyof Config>(
+  key: Key,
+  value: Config[Key],
+  override?: boolean,
+): void {
+  if (EnterpriseUtil.configItemExists(key) && !override) {
+    // If item is in global config and we're not trying to override
+    return;
+  }
+
+  configSchemata[key].parse(value);
+  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: unknown) {
+    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);
+      Sentry.captureException(error);
+    }
+  }
+
+  db = new JsonDB(settingsJsonPath, true, true);
+}

app/common/default-util.ts

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+
+import {app} from "./remote";
+
+let setupCompleted = false;
+
+const zulipDir = app.getPath("userData");
+const logDir = `${zulipDir}/Logs/`;
+const configDir = `${zulipDir}/config/`;
+export const initSetUp = (): void => {
+  // If it is the first time the app is running
+  // create zulip dir in userData folder to
+  // avoid errors
+  if (!setupCompleted) {
+    if (!fs.existsSync(zulipDir)) {
+      fs.mkdirSync(zulipDir);
+    }
+
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir);
+    }
+
+    // Migrate config files from app data folder to config folder inside app
+    // data folder. This will be done once when a user updates to the new version.
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir);
+      const domainJson = `${zulipDir}/domain.json`;
+      const settingsJson = `${zulipDir}/settings.json`;
+      const updatesJson = `${zulipDir}/updates.json`;
+      const windowStateJson = `${zulipDir}/window-state.json`;
+      const configData = [
+        {
+          path: domainJson,
+          fileName: "domain.json",
+        },
+        {
+          path: settingsJson,
+          fileName: "settings.json",
+        },
+        {
+          path: updatesJson,
+          fileName: "updates.json",
+        },
+      ];
+      for (const data of configData) {
+        if (fs.existsSync(data.path)) {
+          fs.copyFileSync(data.path, configDir + data.fileName);
+          fs.unlinkSync(data.path);
+        }
+      }
+
+      // `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);
+      }
+    }
+
+    setupCompleted = true;
+  }
+};

app/common/dnd-util.ts

@@ -0,0 +1,60 @@
+import process from "node:process";
+
+import type * as z from "zod";
+
+import type {dndSettingsSchemata} from "./config-schemata";
+import * as ConfigUtil from "./config-util";
+
+export type DndSettings = {
+  [Key in keyof typeof dndSettingsSchemata]: z.output<
+    typeof dndSettingsSchemata[Key]
+  >;
+};
+
+type SettingName = keyof DndSettings;
+
+interface Toggle {
+  dnd: boolean;
+  newSettings: Partial<DndSettings>;
+}
+
+export function toggle(): Toggle {
+  const dnd = !ConfigUtil.getConfigItem("dnd", false);
+  const dndSettingList: SettingName[] = ["showNotification", "silent"];
+  if (process.platform === "win32") {
+    dndSettingList.push("flashTaskbarOnMessage");
+  }
+
+  let newSettings: Partial<DndSettings>;
+  if (dnd) {
+    const oldSettings: Partial<DndSettings> = {};
+    newSettings = {};
+
+    // Iterate through the dndSettingList.
+    for (const settingName of dndSettingList) {
+      // Store the current value of setting.
+      oldSettings[settingName] = ConfigUtil.getConfigItem(
+        settingName,
+        settingName !== "silent",
+      );
+      // New value of setting.
+      newSettings[settingName] = settingName === "silent";
+    }
+
+    // Store old value in oldSettings.
+    ConfigUtil.setConfigItem("dndPreviousSettings", oldSettings);
+  } else {
+    newSettings = ConfigUtil.getConfigItem("dndPreviousSettings", {
+      showNotification: true,
+      silent: false,
+      ...(process.platform === "win32" && {flashTaskbarOnMessage: true}),
+    });
+  }
+
+  for (const settingName of dndSettingList) {
+    ConfigUtil.setConfigItem(settingName, newSettings[settingName]!);
+  }
+
+  ConfigUtil.setConfigItem("dnd", dnd);
+  return {dnd, newSettings};
+}

app/common/enterprise-util.ts

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+import * as z from "zod";
+
+import {enterpriseConfigSchemata} from "./config-schemata";
+import Logger from "./logger-util";
+
+type EnterpriseConfig = {
+  [Key in keyof typeof enterpriseConfigSchemata]: z.output<
+    typeof enterpriseConfigSchemata[Key]
+  >;
+};
+
+const logger = new Logger({
+  file: "enterprise-util.log",
+});
+
+let enterpriseSettings: Partial<EnterpriseConfig>;
+let configFile: boolean;
+
+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";
+  }
+
+  enterpriseFile = path.resolve(enterpriseFile);
+  if (fs.existsSync(enterpriseFile)) {
+    configFile = true;
+    try {
+      const file = fs.readFileSync(enterpriseFile, "utf8");
+      const data: unknown = JSON.parse(file);
+      enterpriseSettings = z
+        .object(enterpriseConfigSchemata)
+        .partial()
+        .parse(data);
+    } catch (error: unknown) {
+      logger.log("Error while JSON parsing global_config.json: ");
+      logger.log(error);
+    }
+  } else {
+    configFile = false;
+  }
+}
+
+export function hasConfigFile(): boolean {
+  return configFile;
+}
+
+export function getConfigItem<Key extends keyof EnterpriseConfig>(
+  key: Key,
+  defaultValue: EnterpriseConfig[Key],
+): EnterpriseConfig[Key] {
+  reloadDb();
+  if (!configFile) {
+    return defaultValue;
+  }
+
+  const value = enterpriseSettings[key];
+  return value === undefined ? defaultValue : (value as EnterpriseConfig[Key]);
+}
+
+export function configItemExists(key: keyof EnterpriseConfig): 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/common/html.ts

@@ -0,0 +1,26 @@
+import {htmlEscape} from "escape-goat";
+
+export class Html {
+  html: string;
+
+  constructor({html}: {html: string}) {
+    this.html = html;
+  }
+
+  join(htmls: readonly Html[]): Html {
+    return new Html({html: htmls.map((html) => html.html).join(this.html)});
+  }
+}
+
+export function html(
+  template: TemplateStringsArray,
+  ...values: unknown[]
+): Html {
+  let html = template[0];
+  for (const [index, value] of values.entries()) {
+    html += value instanceof Html ? value.html : htmlEscape(String(value));
+    html += template[index + 1];
+  }
+
+  return new Html({html});
+}

app/common/link-util.ts

@@ -0,0 +1,43 @@
+import {shell} from "electron/common";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import {html} from "./html";
+
+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,
+      html`
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="UTF-8" />
+            <meta http-equiv="Refresh" content="0; url=${url.href}" />
+            <title>Redirecting</title>
+            <style>
+              html {
+                font-family: menu, "Helvetica Neue", sans-serif;
+              }
+            </style>
+          </head>
+          <body>
+            <p>Opening <a href="${url.href}">${url.href}</a>…</p>
+          </body>
+        </html>
+      `.html,
+    );
+    await shell.openPath(file);
+    setTimeout(() => {
+      fs.unlinkSync(file);
+      fs.rmdirSync(dir);
+    }, 15_000);
+  }
+}

app/common/logger-util.ts

@@ -0,0 +1,89 @@
+import {Console} from "node:console";
+import fs from "node:fs";
+import os from "node:os";
+import process from "node:process";
+
+import {initSetUp} from "./default-util";
+import {app} from "./remote";
+
+interface LoggerOptions {
+  file?: string;
+}
+
+initSetUp();
+
+const logDir = `${app.getPath("userData")}/Logs`;
+
+type Level = "log" | "debug" | "info" | "warn" | "error";
+
+export default class Logger {
+  nodeConsole: Console;
+
+  constructor(options: LoggerOptions = {}) {
+    let {file = "console.log"} = options;
+
+    file = `${logDir}/${file}`;
+
+    // Trim log according to type of process
+    if (process.type === "renderer") {
+      requestIdleCallback(async () => this.trimLog(file));
+    } else {
+      process.nextTick(async () => this.trimLog(file));
+    }
+
+    const fileStream = fs.createWriteStream(file, {flags: "a"});
+    const nodeConsole = new Console(fileStream);
+
+    this.nodeConsole = nodeConsole;
+  }
+
+  _log(type: Level, ...args: unknown[]): void {
+    args.unshift(this.getTimestamp() + " |\t");
+    args.unshift(type.toUpperCase() + " |");
+    this.nodeConsole[type](...args);
+    console[type](...args);
+  }
+
+  log(...args: unknown[]): void {
+    this._log("log", ...args);
+  }
+
+  debug(...args: unknown[]): void {
+    this._log("debug", ...args);
+  }
+
+  info(...args: unknown[]): void {
+    this._log("info", ...args);
+  }
+
+  warn(...args: unknown[]): void {
+    this._log("warn", ...args);
+  }
+
+  error(...args: unknown[]): void {
+    this._log("error", ...args);
+  }
+
+  getTimestamp(): string {
+    const date = new Date();
+    const timestamp =
+      `${date.getMonth()}/${date.getDate()} ` +
+      `${date.getMinutes()}:${date.getSeconds()}`;
+    return timestamp;
+  }
+
+  async trimLog(file: string): Promise<void> {
+    const data = await fs.promises.readFile(file, "utf8");
+
+    const maxLogFileLines = 500;
+    const logs = data.split(os.EOL);
+    const logLength = logs.length - 1;
+
+    // Keep bottom maxLogFileLines of each log instance
+    if (logLength > maxLogFileLines) {
+      const trimmedLogs = logs.slice(logLength - maxLogFileLines);
+      const toWrite = trimmedLogs.join(os.EOL);
+      await fs.promises.writeFile(file, toWrite);
+    }
+  }
+}

app/common/messages.ts

@@ -0,0 +1,38 @@
+interface DialogBoxError {
+  title: string;
+  content: string;
+}
+
+export function invalidZulipServerError(domain: string): string {
+  return `${domain} does not appear to be a valid Zulip server. Make sure that
+ • You can connect to that URL in a web browser.
+ • If you need a proxy to connect to the Internet, that you've configured your proxy in the Network settings.
+ • It's a Zulip server. (The oldest supported version is 1.6).
+ • The server has a valid certificate.
+ • The SSL is correctly configured for the certificate. Check out the SSL troubleshooting guide -
+ https://zulip.readthedocs.io/en/stable/production/ssl-certificates.html`;
+}
+
+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/common/remote.ts

@@ -0,0 +1,8 @@
+import process from "node:process";
+
+export const {app, dialog} =
+  process.type === "renderer"
+    ? // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+      (require("@electron/remote") as typeof import("@electron/remote"))
+    : // eslint-disable-next-line @typescript-eslint/no-require-imports
+      require("electron/main");

app/common/translation-util.ts

@@ -0,0 +1,18 @@
+import path from "node:path";
+
+import i18n from "i18n";
+
+import * as ConfigUtil from "./config-util";
+
+i18n.configure({
+  directory: path.join(__dirname, "../translations/"),
+  updateFiles: false,
+});
+
+/* Fetches the current appLocale from settings.json */
+const appLocale = ConfigUtil.getConfigItem("appLanguage", "en");
+
+/* If no locale present in the json, en is set default */
+export function __(phrase: string): string {
+  return i18n.__({phrase, locale: appLocale ? appLocale : "en"});
+}

app/common/typed-ipc.ts

@@ -0,0 +1,82 @@
+import type {DndSettings} from "./dnd-util";
+import type {MenuProps, ServerConf} from "./types";
+
+export interface MainMessage {
+  "clear-app-settings": () => void;
+  "configure-spell-checker": () => void;
+  "fetch-user-agent": () => string;
+  "focus-app": () => void;
+  "focus-this-webview": () => void;
+  "permission-callback": (permissionCallbackId: number, grant: boolean) => void;
+  "quit-app": () => void;
+  "realm-icon-changed": (serverURL: string, iconURL: string) => void;
+  "realm-name-changed": (serverURL: string, realmName: string) => void;
+  "reload-full-app": () => void;
+  "save-last-tab": (index: number) => void;
+  "switch-server-tab": (index: number) => void;
+  "toggle-app": () => void;
+  "toggle-badge-option": (newValue: boolean) => void;
+  "toggle-menubar": (showMenubar: boolean) => void;
+  toggleAutoLauncher: (AutoLaunchValue: boolean) => void;
+  "unread-count": (unreadCount: number) => void;
+  "update-badge": (messageCount: number) => void;
+  "update-menu": (props: MenuProps) => void;
+  "update-taskbar-icon": (data: string, text: string) => void;
+}
+
+export interface MainCall {
+  "get-server-settings": (domain: string) => ServerConf;
+  "is-online": (url: string) => boolean;
+  "save-server-icon": (iconURL: string) => string;
+}
+
+export interface RendererMessage {
+  back: () => void;
+  "copy-zulip-url": () => void;
+  destroytray: () => void;
+  "enter-fullscreen": () => void;
+  focus: () => void;
+  "focus-webview-with-id": (webviewId: number) => void;
+  forward: () => void;
+  "hard-reload": () => void;
+  "leave-fullscreen": () => void;
+  "log-out": () => void;
+  logout: () => void;
+  "new-server": () => void;
+  "open-about": () => void;
+  "open-help": () => void;
+  "open-network-settings": () => void;
+  "open-org-tab": () => void;
+  "open-settings": () => void;
+  "permission-request": (
+    options: {webContentsId: number | null; origin: string; permission: string},
+    rendererCallbackId: number,
+  ) => void;
+  "play-ding-sound": () => void;
+  "reload-current-viewer": () => void;
+  "reload-proxy": (showAlert: boolean) => void;
+  "reload-viewer": () => void;
+  "render-taskbar-icon": (messageCount: number) => void;
+  "set-active": () => void;
+  "set-idle": () => void;
+  "show-keyboard-shortcuts": () => void;
+  "show-notification-settings": () => void;
+  "switch-server-tab": (index: number) => void;
+  "tab-devtools": () => void;
+  "toggle-autohide-menubar": (
+    autoHideMenubar: boolean,
+    updateMenu: boolean,
+  ) => void;
+  "toggle-dnd": (state: boolean, newSettings: Partial<DndSettings>) => void;
+  "toggle-sidebar": (show: boolean) => void;
+  "toggle-silent": (state: boolean) => void;
+  "toggle-tray": (state: boolean) => void;
+  toggletray: () => void;
+  tray: (arg: number) => void;
+  "update-realm-icon": (serverURL: string, iconURL: string) => void;
+  "update-realm-name": (serveRURL: string, realmName: string) => void;
+  "webview-reload": () => void;
+  zoomActualSize: () => void;
+  zoomIn: () => void;
+  zoomOut: () => void;
+}

app/common/types.ts

@@ -0,0 +1,26 @@
+export interface MenuProps {
+  tabs: TabData[];
+  activeTabIndex?: number;
+  enableMenu?: boolean;
+}
+
+export type NavItem =
+  | "General"
+  | "Network"
+  | "AddServer"
+  | "Organizations"
+  | "Shortcuts";
+
+export interface ServerConf {
+  url: string;
+  alias: string;
+  icon: string;
+}
+
+export type TabRole = "server" | "function";
+
+export interface TabData {
+  role: TabRole;
+  name: string;
+  index: number;
+}

app/main/autoupdater.ts

@@ -1,104 +1,115 @@
-import { app, dialog } from 'electron';
+import {shell} from "electron/common";
-import { autoUpdater } from 'electron-updater';
+import {app, dialog, session} from "electron/main";
-import { linuxUpdateNotification } from './linuxupdater';	// Required only in case of linux
+import process from "node:process";
+import util from "node:util";
 
-import log from 'electron-log';
+import log from "electron-log";
-import isDev from 'electron-is-dev';
+import type {UpdateDownloadedEvent, UpdateInfo} from "electron-updater";
-import * as ConfigUtil from '../renderer/js/utils/config-util';
+import {autoUpdater} from "electron-updater";
-import * as LinkUtil from '../renderer/js/utils/link-util';
 
-export function appUpdater(updateFromMenu = false): void {
+import * as ConfigUtil from "../common/config-util";
+
+import {linuxUpdateNotification} from "./linuxupdater"; // Required only in case of linux
+
+const sleep = util.promisify(setTimeout);
+
+export async function appUpdater(updateFromMenu = false): Promise<void> {
   // Don't initiate auto-updates in development
-	if (isDev) {
+  if (!app.isPackaged) {
     return;
   }
 
-	if (process.platform === 'linux' && !process.env.APPIMAGE) {
+  if (process.platform === "linux" && !process.env.APPIMAGE) {
-		linuxUpdateNotification();
+    const ses = session.fromPartition("persist:webviewsession");
+    await linuxUpdateNotification(ses);
     return;
   }
 
   let updateAvailable = false;
 
-	// Create Logs directory
-	const LogsDir = `${app.getPath('userData')}/Logs`;
-
   // Log whats happening
-	log.transports.file.file = `${LogsDir}/updates.log`;
+  log.transports.file.fileName = "updates.log";
-	log.transports.file.level = 'info';
+  log.transports.file.level = "info";
   autoUpdater.logger = log;
 
   // Handle auto updates for beta/pre releases
-	const isBetaUpdate = ConfigUtil.getConfigItem('betaUpdate');
+  const isBetaUpdate = ConfigUtil.getConfigItem("betaUpdate", false);
 
-	autoUpdater.allowPrerelease = isBetaUpdate || false;
+  autoUpdater.allowPrerelease = isBetaUpdate;
 
-	const eventsListenerRemove = ['update-available', 'update-not-available'];
+  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 => {
+      for (const event of eventsListenerRemove) {
         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({
-				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();
+
+      await dialog.showMessageBox({
+        message: "No updates available",
+        detail: `You are running the latest version of Zulip Desktop.\nVersion: ${app.getVersion()}`,
+      });
     }
   });
 
-	autoUpdater.on('error', async error => {
+  autoUpdater.on("error", async (error: Error) => {
     if (updateFromMenu) {
-			const messageText = (updateAvailable) ? ('Unable to download the updates') : ('Unable to check for updates');
+      // Remove all autoUpdator listeners so that next time autoUpdator is manually called these
-			const { response } = await dialog.showMessageBox({
+      // listeners don't trigger multiple times.
-				type: 'error',
+      autoUpdater.removeAllListeners();
-				buttons: ['Manual Download', 'Cancel'],
+
+      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).toString() + `\n\nThe latest version of Zulip Desktop is available at -\nhttps://zulipchat.com/apps/.\n
+        detail: `Error: ${error.message}
-				Current Version: ${app.getVersion()}`
+
+The latest version of Zulip Desktop is available at -
+https://zulip.com/apps/.
+Current Version: ${app.getVersion()}`,
       });
       if (response === 0) {
-				LinkUtil.openBrowser(new URL('https://zulipchat.com/apps/'));
+        await shell.openExternal("https://zulip.com/apps/");
       }
-			// Remove all autoUpdator listeners so that next time autoUpdator is manually called these
-			// listeners don't trigger multiple times.
-			autoUpdater.removeAllListeners();
     }
   });
 
   // Ask the user if update is available
-	autoUpdater.on('update-downloaded', async event => {
+  autoUpdater.on("update-downloaded", async (event: UpdateDownloadedEvent) => {
     // Ask user to update the app
-		const { response } = await dialog.showMessageBox({
+    const {response} = await dialog.showMessageBox({
-			type: 'question',
+      type: "question",
-			buttons: ['Install and Relaunch', 'Install Later'],
+      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'
+      detail: "It will be installed the next time you restart the application",
     });
     if (response === 0) {
-			setTimeout(() => {
+      await sleep(1000);
       autoUpdater.quitAndInstall();
-				// force app to quit. This is just a workaround, ideally autoUpdater.quitAndInstall() should relaunch the app.
+      // Force app to quit. This is just a workaround, ideally autoUpdater.quitAndInstall() should relaunch the app.
       app.quit();
-			}, 1000);
     }
   });
   // Init for updates
-	autoUpdater.checkForUpdates();
+  await autoUpdater.checkForUpdates();
 }

app/main/badge-settings.ts

@@ -0,0 +1,61 @@
+import {nativeImage} from "electron/common";
+import type {BrowserWindow} from "electron/main";
+import {app} from "electron/main";
+import process from "node:process";
+
+import * as ConfigUtil from "../common/config-util";
+
+import {send} from "./typed-ipc-main";
+
+function showBadgeCount(messageCount: number, mainWindow: BrowserWindow): void {
+  if (process.platform === "win32") {
+    updateOverlayIcon(messageCount, mainWindow);
+  } else {
+    app.badgeCount = messageCount;
+  }
+}
+
+function hideBadgeCount(mainWindow: BrowserWindow): void {
+  if (process.platform === "win32") {
+    mainWindow.setOverlayIcon(null, "");
+  } else {
+    app.badgeCount = 0;
+  }
+}
+
+export function updateBadge(
+  badgeCount: number,
+  mainWindow: BrowserWindow,
+): void {
+  if (ConfigUtil.getConfigItem("badgeOption", true)) {
+    showBadgeCount(badgeCount, mainWindow);
+  } else {
+    hideBadgeCount(mainWindow);
+  }
+}
+
+function updateOverlayIcon(
+  messageCount: number,
+  mainWindow: BrowserWindow,
+): void {
+  if (!mainWindow.isFocused()) {
+    mainWindow.flashFrame(
+      ConfigUtil.getConfigItem("flashTaskbarOnMessage", true),
+    );
+  }
+
+  if (messageCount === 0) {
+    mainWindow.setOverlayIcon(null, "");
+  } else {
+    send(mainWindow.webContents, "render-taskbar-icon", messageCount);
+  }
+}
+
+export function updateTaskbarIcon(
+  data: string,
+  text: string,
+  mainWindow: BrowserWindow,
+): void {
+  const img = nativeImage.createFromDataURL(data);
+  mainWindow.setOverlayIcon(img, text);
+}

app/main/handle-external-link.ts

@@ -0,0 +1,157 @@
+import {shell} from "electron/common";
+import type {
+  HandlerDetails,
+  SaveDialogOptions,
+  WebContents,
+} from "electron/main";
+import {Notification, app} from "electron/main";
+import fs from "node:fs";
+import path from "node:path";
+
+import * as ConfigUtil from "../common/config-util";
+import * as LinkUtil from "../common/link-util";
+
+import {send} from "./typed-ipc-main";
+
+function isUploadsUrl(server: string, url: URL): boolean {
+  return url.origin === server && url.pathname.startsWith("/user_uploads/");
+}
+
+function downloadFile({
+  contents,
+  url,
+  downloadPath,
+  completed,
+  failed,
+}: {
+  contents: WebContents;
+  url: string;
+  downloadPath: string;
+  completed(filePath: string, fileName: string): Promise<void>;
+  failed(state: string): void;
+}) {
+  contents.downloadURL(url);
+  contents.session.once("will-download", async (_event: Event, item) => {
+    if (ConfigUtil.getConfigItem("promptDownload", false)) {
+      const showDialogOptions: SaveDialogOptions = {
+        defaultPath: path.join(downloadPath, item.getFilename()),
+      };
+      item.setSaveDialogOptions(showDialogOptions);
+    } else {
+      const getTimeStamp = (): number => {
+        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 filePath = path.join(downloadPath, item.getFilename());
+
+      // 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 updatedListener = (_event: Event, state: string): void => {
+      switch (state) {
+        case "interrupted": {
+          // Can interrupted to due to network error, cancel download then
+          console.log(
+            "Download interrupted, cancelling and fallback to dialog download.",
+          );
+          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", async (_event: Event, state) => {
+      if (state === "completed") {
+        await completed(item.getSavePath(), path.basename(item.getSavePath()));
+      } else {
+        console.log("Download failed state:", state);
+        failed(state);
+      }
+
+      // To stop item for listening to updated events of this file
+      item.removeListener("updated", updatedListener);
+    });
+  });
+}
+
+export default function handleExternalLink(
+  contents: WebContents,
+  details: HandlerDetails,
+  mainContents: WebContents,
+): void {
+  const url = new URL(details.url);
+  const downloadPath = ConfigUtil.getConfigItem(
+    "downloadsPath",
+    `${app.getPath("downloads")}`,
+  );
+
+  if (isUploadsUrl(new URL(contents.getURL()).origin, url)) {
+    downloadFile({
+      contents,
+      url: url.href,
+      downloadPath,
+      async completed(filePath: string, fileName: string) {
+        const downloadNotification = new Notification({
+          title: "Download Complete",
+          body: `Click to show ${fileName} in folder`,
+          silent: true, // We'll play our own sound - ding.ogg
+        });
+        downloadNotification.on("click", () => {
+          // Reveal file in download folder
+          shell.showItemInFolder(filePath);
+        });
+        downloadNotification.show();
+
+        // Play sound to indicate download complete
+        if (!ConfigUtil.getConfigItem("silent", false)) {
+          send(mainContents, "play-ding-sound");
+        }
+      },
+      failed(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)) {
+            new Notification({
+              title: "Download Complete",
+              body: "Download failed",
+            }).show();
+          } else {
+            contents.downloadURL(url.href);
+          }
+        }
+      },
+    });
+  } else {
+    (async () => LinkUtil.openBrowser(url))();
+  }
+}

app/main/index.ts

@@ -1,54 +1,50 @@
-import { sentryInit } from '../renderer/js/utils/sentry-util';
+import type {IpcMainEvent, WebContents} from "electron/main";
-import { appUpdater } from './autoupdater';
+import {BrowserWindow, app, dialog, powerMonitor, session} from "electron/main";
-import { setAutoLaunch } from './startup';
+import path from "node:path";
+import process from "node:process";
 
-import windowStateKeeper from 'electron-window-state';
+import * as remoteMain from "@electron/remote/main";
-import path from 'path';
+import windowStateKeeper from "electron-window-state";
-import fs from 'fs';
-import electron, { app, ipcMain, session, dialog } from 'electron';
 
-import * as AppMenu from './menu';
+import * as ConfigUtil from "../common/config-util";
-import * as BadgeSettings from '../renderer/js/pages/preference/badge-settings';
+import type {RendererMessage} from "../common/typed-ipc";
-import * as ConfigUtil from '../renderer/js/utils/config-util';
+import type {MenuProps} from "../common/types";
-import * as ProxyUtil from '../renderer/js/utils/proxy-util';
 
-interface PatchedGlobal extends NodeJS.Global {
+import {appUpdater} from "./autoupdater";
-	mainWindowState: windowStateKeeper.State;
+import * as BadgeSettings from "./badge-settings";
-}
+import handleExternalLink from "./handle-external-link";
+import * as AppMenu from "./menu";
+import {_getServerSettings, _isOnline, _saveServerIcon} from "./request";
+import {sentryInit} from "./sentry";
+import {setAutoLaunch} from "./startup";
+import {ipcMain, send} from "./typed-ipc-main";
 
-const globalPatched = global as PatchedGlobal;
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const {GDK_BACKEND} = process.env;
+
+// Initialize sentry for main process
+sentryInit();
+
+let mainWindowState: windowStateKeeper.State;
 
 // Prevent window being garbage collected
-let mainWindow: Electron.BrowserWindow;
+let mainWindow: BrowserWindow;
 let badgeCount: number;
 
 let isQuitting = false;
 
 // Load this url in main window
-const mainURL = 'file://' + path.join(__dirname, '../renderer', 'main.html');
+const mainUrl = "file://" + path.join(__dirname, "../renderer", "main.html");
 
-const singleInstanceLock = app.requestSingleInstanceLock();
+const permissionCallbacks = new Map<number, (grant: boolean) => void>();
-if (singleInstanceLock) {
+let nextPermissionCallbackId = 0;
-	app.on('second-instance', () => {
-		if (mainWindow) {
-			if (mainWindow.isMinimized()) {
-				mainWindow.restore();
-			}
 
-			mainWindow.show();
+const appIcon = path.join(__dirname, "../resources", "Icon");
-		}
-	});
-} else {
-	app.quit();
-}
 
-const APP_ICON = path.join(__dirname, '../resources', 'Icon');
+const iconPath = (): string =>
+  appIcon + (process.platform === "win32" ? ".ico" : ".png");
 
-const iconPath = (): string => {
+// Toggle the app window
-	return APP_ICON + (process.platform === 'win32' ? '.ico' : '.png');
-};
-
-// toggle the app window
 const toggleApp = (): void => {
   if (!mainWindow.isVisible() || mainWindow.isMinimized()) {
     mainWindow.show();
@@ -57,51 +53,48 @@ const toggleApp = (): void => {
   }
 };
 
-function createMainWindow(): Electron.BrowserWindow {
+function createMainWindow(): BrowserWindow {
   // Load the previous state with fallback to defaults
-	const mainWindowState: windowStateKeeper.State = windowStateKeeper({
+  mainWindowState = windowStateKeeper({
     defaultWidth: 1100,
     defaultHeight: 720,
-		path: `${app.getPath('userData')}/config`
+    path: `${app.getPath("userData")}/config`,
   });
 
-	// Let's keep the window position global so that we can access it in other process
+  const win = new BrowserWindow({
-	globalPatched.mainWindowState = mainWindowState;
-
-	const win = new electron.BrowserWindow({
     // This settings needs to be saved in config
-		title: 'Zulip',
+    title: "Zulip",
     icon: iconPath(),
     x: mainWindowState.x,
     y: mainWindowState.y,
     width: mainWindowState.width,
     height: mainWindowState.height,
-		minWidth: 300,
+    minWidth: 500,
     minHeight: 400,
     webPreferences: {
-			plugins: true,
+      preload: require.resolve("../renderer/js/main"),
-			nodeIntegration: true,
+      webviewTag: true,
-			partition: 'persist:webviewsession',
-			webviewTag: true
     },
-		show: false
+    show: false,
+  });
+  remoteMain.enable(win.webContents);
+
+  win.on("focus", () => {
+    send(win.webContents, "focus");
   });
 
-	win.on('focus', () => {
+  (async () => win.loadURL(mainUrl))();
-		win.webContents.send('focus');
-	});
-
-	win.loadURL(mainURL);
 
   // Keep the app running in background on close event
-	win.on('close', event => {
+  win.on("close", (event) => {
-		if (ConfigUtil.getConfigItem('quitOnClose')) {
+    if (ConfigUtil.getConfigItem("quitOnClose", false)) {
       app.quit();
     }
+
     if (!isQuitting) {
       event.preventDefault();
 
-			if (process.platform === 'darwin') {
+      if (process.platform === "darwin") {
         app.hide();
       } else {
         win.hide();
@@ -109,20 +102,20 @@ function createMainWindow(): Electron.BrowserWindow {
     }
   });
 
-	win.setTitle('Zulip');
+  win.setTitle("Zulip");
 
-	win.on('enter-full-screen', () => {
+  win.on("enter-full-screen", () => {
-		win.webContents.send('enter-fullscreen');
+    send(win.webContents, "enter-fullscreen");
   });
 
-	win.on('leave-full-screen', () => {
+  win.on("leave-full-screen", () => {
-		win.webContents.send('leave-fullscreen');
+    send(win.webContents, "leave-fullscreen");
   });
 
   //  To destroy tray icon when navigate to a new URL
-	win.webContents.on('will-navigate', event => {
+  win.webContents.on("will-navigate", (event) => {
     if (event) {
-			win.webContents.send('destroytray');
+      send(win.webContents, "destroytray");
     }
   });
 
@@ -134,280 +127,263 @@ function createMainWindow(): Electron.BrowserWindow {
   return win;
 }
 
-// Decrease load on GPU (experimental)
+(async () => {
-app.disableHardwareAcceleration();
+  if (!app.requestSingleInstanceLock()) {
-
+    app.quit();
-// Temporary fix for Electron render colors differently
+    return;
-// 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 there is already a window show it
-		mainWindow.show();
-	} else {
-		mainWindow = createMainWindow();
   }
-});
 
-app.on('ready', () => {
+  await app.whenReady();
-	const ses = session.fromPartition('persist:webviewsession');
+
+  if (process.env.GDK_BACKEND !== GDK_BACKEND) {
+    console.warn(
+      "Reverting GDK_BACKEND to work around https://github.com/electron/electron/issues/28436",
+    );
+    if (GDK_BACKEND === undefined) {
+      delete process.env.GDK_BACKEND;
+    } else {
+      process.env.GDK_BACKEND = GDK_BACKEND;
+    }
+  }
+
+  // Used for notifications on Windows
+  app.setAppUserModelId("org.zulip.zulip-electron");
+
+  remoteMain.initialize();
+
+  app.on("second-instance", () => {
+    if (mainWindow) {
+      if (mainWindow.isMinimized()) {
+        mainWindow.restore();
+      }
+
+      mainWindow.show();
+    }
+  });
+
+  ipcMain.on(
+    "permission-callback",
+    (event: Event, permissionCallbackId: number, grant: boolean) => {
+      permissionCallbacks.get(permissionCallbackId)?.(grant);
+      permissionCallbacks.delete(permissionCallbackId);
+    },
+  );
+
+  // This event is only available on macOS. Triggers when you click on the dock icon.
+  app.on("activate", () => {
+    mainWindow.show();
+  });
+
+  app.on("web-contents-created", (_event: Event, contents: WebContents) => {
+    contents.setWindowOpenHandler((details) => {
+      handleExternalLink(contents, details, page);
+      return {action: "deny"};
+    });
+  });
+
+  const ses = session.fromPartition("persist:webviewsession");
   ses.setUserAgent(`ZulipElectron/${app.getVersion()} ${ses.getUserAgent()}`);
 
+  function configureSpellChecker() {
+    const enable = ConfigUtil.getConfigItem("enableSpellchecker", true);
+    if (enable && process.platform !== "darwin") {
+      ses.setSpellCheckerLanguages(
+        ConfigUtil.getConfigItem("spellcheckerLanguages", null) ?? [],
+      );
+    }
+
+    ses.setSpellCheckerEnabled(enable);
+  }
+
+  configureSpellChecker();
+  ipcMain.on("configure-spell-checker", configureSpellChecker);
+
   AppMenu.setMenu({
-		tabs: []
+    tabs: [],
   });
   mainWindow = createMainWindow();
 
   // Auto-hide menu bar on Windows + Linux
-	if (process.platform !== 'darwin') {
+  if (process.platform !== "darwin") {
-		const shouldHideMenu = ConfigUtil.getConfigItem('autoHideMenubar') || false;
+    const shouldHideMenu = ConfigUtil.getConfigItem("autoHideMenubar", false);
     mainWindow.autoHideMenuBar = shouldHideMenu;
     mainWindow.setMenuBarVisibility(!shouldHideMenu);
   }
 
-	// Initialize sentry for main process
-	const errorReporting = ConfigUtil.getConfigItem('errorReporting');
-	if (errorReporting) {
-		sentryInit();
-	}
-
-	const isSystemProxy = ConfigUtil.getConfigItem('useSystemProxy');
-
-	if (isSystemProxy) {
-		ProxyUtil.resolveSystemProxy(mainWindow);
-	}
-
   const page = mainWindow.webContents;
 
-	page.on('dom-ready', () => {
+  page.on("dom-ready", () => {
-		if (ConfigUtil.getConfigItem('startMinimized')) {
+    if (ConfigUtil.getConfigItem("startMinimized", false)) {
       mainWindow.hide();
     } else {
       mainWindow.show();
     }
   });
 
-	ipcMain.on('fetch-user-agent', event => {
+  ipcMain.on("fetch-user-agent", (event) => {
-		event.returnValue = session.fromPartition('persist:webviewsession').getUserAgent();
+    event.returnValue = session
+      .fromPartition("persist:webviewsession")
+      .getUserAgent();
   });
 
-	page.once('did-frame-finish-load', () => {
+  ipcMain.handle("get-server-settings", async (event, domain: string) =>
+    _getServerSettings(domain, ses),
+  );
+
+  ipcMain.handle("save-server-icon", async (event, url: string) =>
+    _saveServerIcon(url, ses),
+  );
+
+  ipcMain.handle("is-online", async (event, url: string) =>
+    _isOnline(url, ses),
+  );
+
+  page.once("did-frame-finish-load", async () => {
     // Initiate auto-updates on MacOS and Windows
-		if (ConfigUtil.getConfigItem('autoUpdate')) {
+    if (ConfigUtil.getConfigItem("autoUpdate", true)) {
-			appUpdater();
+      await appUpdater();
     }
   });
 
-	const permissionCallbacks = new Map();
+  app.on(
-	let nextPermissionId = 0;
+    "certificate-error",
+    (
+      event: Event,
+      webContents: WebContents,
+      urlString: string,
+      error: string,
+    ) => {
+      const url = new URL(urlString);
+      dialog.showErrorBox(
+        "Certificate error",
+        `The server presented an invalid certificate for ${url.origin}:
 
-	page.session.setPermissionRequestHandler((webContents, permission, callback, details) => {
+${error}`,
+      );
+    },
+  );
+
+  ses.setPermissionRequestHandler(
+    (webContents, permission, callback, details) => {
       const {origin} = new URL(details.requestingUrl);
-		permissionCallbacks.set(nextPermissionId, callback);
+      const permissionCallbackId = nextPermissionCallbackId++;
-		page.send('permission-request', nextPermissionId, {
+      permissionCallbacks.set(permissionCallbackId, callback);
-			webContentsId: webContents.id === mainWindow.webContents.id ?
+      send(
-				null :
+        page,
-				webContents.id,
+        "permission-request",
+        {
+          webContentsId:
+            webContents.id === mainWindow.webContents.id
+              ? null
+              : webContents.id,
           origin,
-			permission
+          permission,
-		});
+        },
-		nextPermissionId++;
+        permissionCallbackId,
-	});
+      );
-
+    },
-	ipcMain.on('permission-response', (event: Event, permissionId: number, grant: boolean) => {
+  );
-		permissionCallbacks.get(permissionId)(grant);
-		permissionCallbacks.delete(permissionId);
-	});
 
   // Temporarily remove this event
-	// electron.powerMonitor.on('resume', () => {
+  // powerMonitor.on('resume', () => {
   // 	mainWindow.reload();
-	// 	page.send('destroytray');
+  // 	send(page, 'destroytray');
   // });
 
-	ipcMain.on('focus-app', () => {
+  ipcMain.on("focus-app", () => {
     mainWindow.show();
   });
 
-	ipcMain.on('quit-app', () => {
+  ipcMain.on("quit-app", () => {
     app.quit();
   });
 
-	// Code to show pdf in a new BrowserWindow (currently commented out due to bug-upstream)
-	// ipcMain.on('pdf-view', (event, url) => {
-	// 	// Paddings for pdfWindow so that it fits into the main browserWindow
-	// 	const paddingWidth = 55;
-	// 	const paddingHeight = 22;
-
-	// 	// Get the config of main browserWindow
-	// 	const mainWindowState = global.mainWindowState;
-
-	// 	// Window to view the pdf file
-	// 	const pdfWindow = new electron.BrowserWindow({
-	// 		x: mainWindowState.x + paddingWidth,
-	// 		y: mainWindowState.y + paddingHeight,
-	// 		width: mainWindowState.width - paddingWidth,
-	// 		height: mainWindowState.height - paddingHeight,
-	// 		webPreferences: {
-	// 			plugins: true,
-	// 			partition: 'persist:webviewsession'
-	// 		}
-	// 	});
-	// 	pdfWindow.loadURL(url);
-
-	// 	// We don't want to have the menu bar in pdf window
-	// 	pdfWindow.setMenu(null);
-	// });
-
   // Reload full app not just webview, useful in debugging
-	ipcMain.on('reload-full-app', () => {
+  ipcMain.on("reload-full-app", () => {
     mainWindow.reload();
-		page.send('destroytray');
+    send(page, "destroytray");
   });
 
-	ipcMain.on('clear-app-settings', () => {
+  ipcMain.on("clear-app-settings", () => {
-		globalPatched.mainWindowState.unmanage();
+    mainWindowState.unmanage();
     app.relaunch();
     app.exit();
   });
 
-	ipcMain.on('toggle-app', () => {
+  ipcMain.on("toggle-app", () => {
     toggleApp();
   });
 
-	ipcMain.on('toggle-badge-option', () => {
+  ipcMain.on("toggle-badge-option", () => {
     BadgeSettings.updateBadge(badgeCount, mainWindow);
   });
 
-	ipcMain.on('toggle-menubar', (_event: Electron.IpcMainEvent, showMenubar: boolean) => {
+  ipcMain.on("toggle-menubar", (_event: IpcMainEvent, showMenubar: boolean) => {
     mainWindow.autoHideMenuBar = showMenubar;
     mainWindow.setMenuBarVisibility(!showMenubar);
-		page.send('toggle-autohide-menubar', showMenubar, true);
+    send(page, "toggle-autohide-menubar", showMenubar, true);
   });
 
-	ipcMain.on('update-badge', (_event: Electron.IpcMainEvent, messageCount: number) => {
+  ipcMain.on("update-badge", (_event: IpcMainEvent, messageCount: number) => {
     badgeCount = messageCount;
     BadgeSettings.updateBadge(badgeCount, mainWindow);
-		page.send('tray', messageCount);
+    send(page, "tray", messageCount);
   });
 
-	ipcMain.on('update-taskbar-icon', (_event: Electron.IpcMainEvent, data: string, text: string) => {
+  ipcMain.on(
+    "update-taskbar-icon",
+    (_event: IpcMainEvent, data: string, text: string) => {
       BadgeSettings.updateTaskbarIcon(data, text, mainWindow);
-	});
+    },
+  );
 
-	ipcMain.on('forward-message', (_event: Electron.IpcMainEvent, listener: string, ...parameters: any[]) => {
+  ipcMain.on(
-		page.send(listener, ...parameters);
+    "forward-message",
-	});
+    <Channel extends keyof RendererMessage>(
+      _event: IpcMainEvent,
+      listener: Channel,
+      ...parameters: Parameters<RendererMessage[Channel]>
+    ) => {
+      send(page, listener, ...parameters);
+    },
+  );
 
-	ipcMain.on('update-menu', (_event: Electron.IpcMainEvent, props: any) => {
+  ipcMain.on("update-menu", (_event: IpcMainEvent, props: MenuProps) => {
     AppMenu.setMenu(props);
+    if (props.activeTabIndex !== undefined) {
       const activeTab = props.tabs[props.activeTabIndex];
-		if (activeTab) {
+      mainWindow.setTitle(`Zulip - ${activeTab.name}`);
-			mainWindow.setTitle(`Zulip - ${activeTab.webview.props.name}`);
     }
   });
 
-	ipcMain.on('toggleAutoLauncher', (_event: Electron.IpcMainEvent, AutoLaunchValue: boolean) => {
+  ipcMain.on(
-		setAutoLaunch(AutoLaunchValue);
+    "toggleAutoLauncher",
+    async (_event: IpcMainEvent, AutoLaunchValue: boolean) => {
+      await setAutoLaunch(AutoLaunchValue);
+    },
+  );
+
+  ipcMain.on(
+    "realm-name-changed",
+    (_event: IpcMainEvent, serverURL: string, realmName: string) => {
+      send(page, "update-realm-name", serverURL, realmName);
+    },
+  );
+
+  ipcMain.on(
+    "realm-icon-changed",
+    (_event: IpcMainEvent, serverURL: string, iconURL: string) => {
+      send(page, "update-realm-icon", serverURL, iconURL);
+    },
+  );
+
+  ipcMain.on("save-last-tab", (_event: IpcMainEvent, index: number) => {
+    ConfigUtil.setConfigItem("lastActiveTab", index);
   });
 
-	ipcMain.on('downloadFile', (_event: Electron.IpcMainEvent, url: string, downloadPath: string) => {
+  ipcMain.on("focus-this-webview", (event: IpcMainEvent) => {
-		page.downloadURL(url);
+    send(page, "focus-webview-with-id", event.sender.id);
-		page.session.once('will-download', async (_event: Event, item) => {
+    mainWindow.show();
-			let setFilePath: string;
-			let shortFileName: string;
-			if (ConfigUtil.getConfigItem('promptDownload', false)) {
-				const showDialogOptions: object = {
-					defaultPath: path.join(downloadPath, item.getFilename())
-				};
-
-				const result = await dialog.showSaveDialog(mainWindow, showDialogOptions);
-				if (result.canceled) {
-					item.cancel();
-					return;
-				}
-				setFilePath = result.filePath;
-				shortFileName = path.basename(setFilePath);
-			} else {
-				const getTimeStamp = (): number => {
-					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 filePath = path.join(downloadPath, item.getFilename());
-
-				// Update the name and path of the file if it already exists
-				const updatedFilePath = path.join(downloadPath, formatFile(filePath));
-				setFilePath = fs.existsSync(filePath) ? updatedFilePath : filePath;
-				shortFileName = fs.existsSync(filePath) ? formatFile(filePath) : item.getFilename();
-			}
-
-			item.setSavePath(setFilePath);
-
-			const updatedListener = (_event: Event, state: string): void => {
-				switch (state) {
-					case 'interrupted': {
-						// Can interrupted to due to network error, cancel download then
-						console.log('Download interrupted, cancelling and fallback to dialog download.');
-						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) => {
-				if (state === 'completed') {
-					page.send('downloadFileCompleted', item.getSavePath(), shortFileName);
-				} else {
-					console.log('Download failed state:', state);
-					page.send('downloadFileFailed');
-				}
-				// To stop item for listening to updated events of this file
-				item.removeListener('updated', updatedListener);
-			});
-		});
-	});
-
-	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.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.IpcMainEvent) => {
-		event.sender.send('error-reporting-val', errorReporting);
-	});
-
-	ipcMain.on('save-last-tab', (_event: Electron.IpcMainEvent, index: number) => {
-		ConfigUtil.setConfigItem('lastActiveTab', index);
   });
 
   // Update user idle status for each realm after every 15s
@@ -415,21 +391,21 @@ app.on('ready', () => {
   setInterval(() => {
     // Set user idle if no activity in 1 second (idleThresholdSeconds)
     const idleThresholdSeconds = 1; // 1 second
-		const idleState = electron.powerMonitor.getSystemIdleState(idleThresholdSeconds);
+    const idleState = powerMonitor.getSystemIdleState(idleThresholdSeconds);
-		if (idleState === 'active') {
+    if (idleState === "active") {
-			page.send('set-active');
+      send(page, "set-active");
     } else {
-			page.send('set-idle');
+      send(page, "set-idle");
     }
   }, idleCheckInterval);
-});
+})();
 
-app.on('before-quit', () => {
+app.on("before-quit", () => {
   isQuitting = true;
 });
 
 // Send crash reports
-process.on('uncaughtException', err => {
+process.on("uncaughtException", (error) => {
-	console.error(err);
+  console.error(error);
-	console.error(err.stack);
+  console.error(error.stack);
 });

app/main/linux-update-util.ts

@@ -0,0 +1,69 @@
+import {app, dialog} from "electron/main";
+import fs from "node:fs";
+import path from "node:path";
+
+import {JsonDB} from "node-json-db";
+import {DataError} from "node-json-db/dist/lib/Errors";
+
+import Logger from "../common/logger-util";
+
+const logger = new Logger({
+  file: "linux-update-util.log",
+});
+
+let db: JsonDB;
+
+reloadDb();
+
+export function getUpdateItem(
+  key: string,
+  defaultValue: true | null = null,
+): true | null {
+  reloadDb();
+  let value: unknown;
+  try {
+    value = db.getObject<unknown>(`/${key}`);
+  } catch (error: unknown) {
+    if (!(error instanceof DataError)) throw error;
+  }
+
+  if (value !== true && value !== null) {
+    setUpdateItem(key, defaultValue);
+    return defaultValue;
+  }
+
+  return value;
+}
+
+export function setUpdateItem(key: string, value: true | null): 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: unknown) {
+    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/main/linuxupdater.ts

@@ -1,48 +1,50 @@
-import { app, Notification } from 'electron';
+import type {Session} from "electron/main";
+import {Notification, app, net} from "electron/main";
 
-import request from 'request';
+import getStream from "get-stream";
-import semver from 'semver';
+import * as semver from "semver";
-import * as ConfigUtil from '../renderer/js/utils/config-util';
+import * as z from "zod";
-import * as ProxyUtil from '../renderer/js/utils/proxy-util';
+
-import * as LinuxUpdateUtil from '../renderer/js/utils/linux-update-util';
+import * as ConfigUtil from "../common/config-util";
-import Logger from '../renderer/js/utils/logger-util';
+import Logger from "../common/logger-util";
+
+import * as LinuxUpdateUtil from "./linux-update-util";
+import {fetchResponse} from "./request";
 
 const logger = new Logger({
-	file: 'linux-update-util.log',
+  file: "linux-update-util.log",
-	timestamp: true
 });
 
-export function linuxUpdateNotification(): void {
+export async function linuxUpdateNotification(session: Session): Promise<void> {
-	let	url = 'https://api.github.com/repos/zulip/zulip-desktop/releases';
+  let url = "https://api.github.com/repos/zulip/zulip-desktop/releases";
-	url = ConfigUtil.getConfigItem('betaUpdate') ? url : url + '/latest';
+  url = ConfigUtil.getConfigItem("betaUpdate", false) ? url : url + "/latest";
-	const proxyEnabled = ConfigUtil.getConfigItem('useManualProxy') || ConfigUtil.getConfigItem('useSystemProxy');
 
-	const options = {
+  try {
-		url,
+    const response = await fetchResponse(net.request({url, session}));
-		headers: {'User-Agent': 'request'},
+    if (response.statusCode !== 200) {
-		proxy: proxyEnabled ? ProxyUtil.getProxy(url) : '',
+      logger.log("Linux update response status: ", response.statusCode);
-		ecdhCurve: 'auto'
-	};
-
-	request(options, (error: any, response: any, body: any) => {
-		if (error) {
-			logger.error('Linux update error.');
-			logger.error(error);
       return;
     }
-		if (response.statusCode < 400) {
+
-			const data = JSON.parse(body);
+    const data: unknown = JSON.parse(await getStream(response));
-			const latestVersion = ConfigUtil.getConfigItem('betaUpdate') ? data[0].tag_name : data.tag_name;
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const latestVersion = ConfigUtil.getConfigItem("betaUpdate", false)
+      ? z.array(z.object({tag_name: z.string()})).parse(data)[0].tag_name
+      : z.object({tag_name: z.string()}).parse(data).tag_name;
+    /* eslint-enable @typescript-eslint/naming-convention */
 
     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);
       }
     }
-		} else {
+  } catch (error: unknown) {
-			logger.log('Linux update response status: ', response.statusCode);
+    logger.error("Linux update error.");
+    logger.error(error);
   }
-	});
 }

app/main/request.ts

@@ -0,0 +1,137 @@
+import type {ClientRequest, IncomingMessage, Session} from "electron/main";
+import {app, net} from "electron/main";
+import fs from "node:fs";
+import path from "node:path";
+import stream from "node:stream";
+import util from "node:util";
+
+import * as Sentry from "@sentry/electron";
+import getStream from "get-stream";
+import * as z from "zod";
+
+import Logger from "../common/logger-util";
+import * as Messages from "../common/messages";
+import type {ServerConf} from "../common/types";
+
+export async function fetchResponse(
+  request: ClientRequest,
+): Promise<IncomingMessage> {
+  return new Promise((resolve, reject) => {
+    request.on("response", resolve);
+    request.on("abort", () => {
+      reject(new Error("Request aborted"));
+    });
+    request.on("error", reject);
+    request.end();
+  });
+}
+
+const pipeline = util.promisify(stream.pipeline);
+
+/* Request: domain-util */
+
+const defaultIconUrl = "../renderer/img/icon.png";
+
+const logger = new Logger({
+  file: "domain-util.log",
+});
+
+const 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) {
+    // eslint-disable-next-line no-bitwise, unicorn/prefer-code-point
+    hash = (hash * 33) ^ url.charCodeAt(--length);
+  }
+
+  // Create 'server-icons' directory if not existed
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+
+  // eslint-disable-next-line no-bitwise
+  return `${dir}/${hash >>> 0}${extension}`;
+};
+
+export const _getServerSettings = async (
+  domain: string,
+  session: Session,
+): Promise<ServerConf> => {
+  const response = await fetchResponse(
+    net.request({
+      url: domain + "/api/v1/server_settings",
+      session,
+    }),
+  );
+  if (response.statusCode !== 200) {
+    throw new Error(Messages.invalidZulipServerError(domain));
+  }
+
+  const data: unknown = JSON.parse(await getStream(response));
+  /* eslint-disable @typescript-eslint/naming-convention */
+  const {realm_name, realm_uri, realm_icon} = z
+    .object({
+      realm_name: z.string(),
+      realm_uri: z.string(),
+      realm_icon: z.string(),
+    })
+    .parse(data);
+  /* eslint-enable @typescript-eslint/naming-convention */
+
+  return {
+    // 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: realm_name,
+  };
+};
+
+export const _saveServerIcon = async (
+  url: string,
+  session: Session,
+): Promise<string> => {
+  try {
+    const response = await fetchResponse(net.request({url, session}));
+    if (response.statusCode !== 200) {
+      logger.log("Could not get server icon.");
+      return defaultIconUrl;
+    }
+
+    const filePath = generateFilePath(url);
+    await pipeline(response, fs.createWriteStream(filePath));
+    return filePath;
+  } catch (error: unknown) {
+    logger.log("Could not get server icon.");
+    logger.log(error);
+    Sentry.captureException(error);
+    return defaultIconUrl;
+  }
+};
+
+/* Request: reconnect-util */
+
+export const _isOnline = async (
+  url: string,
+  session: Session,
+): Promise<boolean> => {
+  try {
+    const response = await fetchResponse(
+      net.request({
+        method: "HEAD",
+        url: `${url}/api/v1/server_settings`,
+        session,
+      }),
+    );
+    const isValidResponse =
+      response.statusCode >= 200 && response.statusCode < 400;
+    return isValidResponse;
+  } catch (error: unknown) {
+    logger.log(error);
+    return false;
+  }
+};

app/main/sentry.ts

@@ -0,0 +1,22 @@
+import {app} from "electron/main";
+
+import * as Sentry from "@sentry/electron";
+
+import {getConfigItem} from "../common/config-util";
+
+export const sentryInit = (): void => {
+  Sentry.init({
+    dsn: "https://628dc2f2864243a08ead72e63f94c7b1@o48127.ingest.sentry.io/204668",
+
+    // Don't report errors in development or if disabled by the user.
+    beforeSend: (event) =>
+      app.isPackaged && getConfigItem("errorReporting", true) ? event : null,
+
+    // 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
+  });
+};

app/main/startup.ts

@@ -1,32 +1,36 @@
-import { app } from 'electron';
+import {app} from "electron/main";
+import process from "node:process";
 
-import AutoLaunch from 'auto-launch';
+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 => {
+import * as ConfigUtil from "../common/config-util";
+
+export const setAutoLaunch = async (
+  AutoLaunchValue: boolean,
+): Promise<void> => {
   // Don't run this in development
-	if (isDev) {
+  if (!app.isPackaged) {
     return;
   }
 
-	const autoLaunchOption = ConfigUtil.getConfigItem('startAtLogin', AutoLaunchValue);
+  const autoLaunchOption = ConfigUtil.getConfigItem(
+    "startAtLogin",
+    AutoLaunchValue,
+  );
 
-	// setLoginItemSettings doesn't support linux
+  // `setLoginItemSettings` doesn't support linux
-	if (process.platform === 'linux') {
+  if (process.platform === "linux") {
-		const ZulipAutoLauncher = new AutoLaunch({
+    const zulipAutoLauncher = new AutoLaunch({
-			name: 'Zulip',
+      name: "Zulip",
-			isHidden: false
+      isHidden: false,
     });
-		if (autoLaunchOption) {
+    await (autoLaunchOption
-			ZulipAutoLauncher.enable();
+      ? zulipAutoLauncher.enable()
-		} else {
+      : zulipAutoLauncher.disable());
-			ZulipAutoLauncher.disable();
-		}
   } else {
     app.setLoginItemSettings({
       openAtLogin: autoLaunchOption,
-			openAsHidden: false
+      openAsHidden: false,
     });
   }
 };

app/main/typed-ipc-main.ts

@@ -0,0 +1,75 @@
+import type {
+  IpcMainEvent,
+  IpcMainInvokeEvent,
+  WebContents,
+} from "electron/main";
+import {
+  ipcMain as untypedIpcMain, // eslint-disable-line no-restricted-imports
+} from "electron/main";
+
+import type {
+  MainCall,
+  MainMessage,
+  RendererMessage,
+} from "../common/typed-ipc.js";
+
+type MainListener<Channel extends keyof MainMessage> =
+  MainMessage[Channel] extends (...args: infer Args) => infer Return
+    ? (event: IpcMainEvent & {returnValue: Return}, ...args: Args) => void
+    : never;
+
+type MainHandler<Channel extends keyof MainCall> = MainCall[Channel] extends (
+  ...args: infer Args
+) => infer Return
+  ? (event: IpcMainInvokeEvent, ...args: Args) => Return | Promise<Return>
+  : never;
+
+export const ipcMain: {
+  on(
+    channel: "forward-message",
+    listener: <Channel extends keyof RendererMessage>(
+      event: IpcMainEvent,
+      channel: Channel,
+      ...args: Parameters<RendererMessage[Channel]>
+    ) => void,
+  ): void;
+  on<Channel extends keyof MainMessage>(
+    channel: Channel,
+    listener: MainListener<Channel>,
+  ): void;
+  once<Channel extends keyof MainMessage>(
+    channel: Channel,
+    listener: MainListener<Channel>,
+  ): void;
+  removeListener<Channel extends keyof MainMessage>(
+    channel: Channel,
+    listener: MainListener<Channel>,
+  ): void;
+  removeAllListeners(channel?: keyof MainMessage): void;
+  handle<Channel extends keyof MainCall>(
+    channel: Channel,
+    handler: MainHandler<Channel>,
+  ): void;
+  handleOnce<Channel extends keyof MainCall>(
+    channel: Channel,
+    handler: MainHandler<Channel>,
+  ): void;
+  removeHandler(channel: keyof MainCall): void;
+} = untypedIpcMain;
+
+export function send<Channel extends keyof RendererMessage>(
+  contents: WebContents,
+  channel: Channel,
+  ...args: Parameters<RendererMessage[Channel]>
+): void {
+  contents.send(channel, ...args);
+}
+
+export function sendToFrame<Channel extends keyof RendererMessage>(
+  contents: WebContents,
+  frameId: number | [number, number],
+  channel: Channel,
+  ...args: Parameters<RendererMessage[Channel]>
+): void {
+  contents.sendToFrame(frameId, channel, ...args);
+}

app/renderer/about.html

@@ -1,33 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-    <head>
-        <meta charset="UTF-8">
-        <link rel="stylesheet" href="css/about.css">
-        <title>Zulip - About</title>
-    </head>
-
-    <body>
-        <div class="about">
-            <img class="logo" src="../resources/zulip.png" />
-            <p class="detail" id="version">v?.?.?</p>
-            <div class="maintenance-info">
-                <p class="detail maintainer">
-                    Maintained by
-                    <a href="https://zulipchat.com" target="_blank" rel="noopener noreferrer">Zulip</a>
-                </p>
-                <p class="detail license">
-                    Available under the
-                    <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 version_tag = document.querySelector('#version');
-            version_tag.innerHTML = 'v' + app.getVersion();
-        </script>
-        <script>require('./js/shared/preventdrag.js')</script>
-    </body>
-</html>

app/renderer/css/about.css

@@ -1,5 +1,7 @@
-body {
+:host {
-    background: rgba(250, 250, 250, 1.000);
+  contain: strict;
+  display: flow-root;
+  background: rgb(250 250 250 / 100%);
   font-family: menu, "Helvetica Neue", sans-serif;
   -webkit-font-smoothing: subpixel-antialiased;
 }
@@ -10,12 +12,13 @@ body {
 }
 
 #version {
-    color: rgba(68, 67, 67, 1.000);
+  color: rgb(68 67 67 / 100%);
   font-size: 1.3em;
   padding-top: 40px;
 }
 
 .about {
+  display: block !important;
   margin: 25vh auto;
   height: 25vh;
   text-align: center;
@@ -23,7 +26,7 @@ body {
 
 .about p {
   font-size: 20px;
-    color: rgba(0, 0, 0, 0.62);
+  color: rgb(0 0 0 / 62%);
 }
 
 .about img {
@@ -47,8 +50,8 @@ body {
   cursor: pointer;
   position: absolute;
   width: 100%;
-    left: 0px;
+  left: 0;
-    color: rgba(68, 68, 68, 1.000);
+  color: rgb(68 68 68 / 100%);
 }
 
 .maintenance-info p {
@@ -58,7 +61,7 @@ body {
 }
 
 p.detail a {
-    color: rgba(53, 95, 76, 1.000);
+  color: rgb(53 95 76 / 100%);
 }
 
 p.detail a:hover {

app/renderer/css/feedback.css

@@ -0,0 +1,19 @@
+:host {
+  --button-color: rgb(69 166 149);
+}
+
+button {
+  background-color: var(--button-color);
+  border-color: var(--button-color);
+}
+
+button:hover,
+button:focus {
+  border-color: var(--button-color);
+  color: var(--button-color);
+}
+
+button:active {
+  background-color: rgb(241 241 241);
+  color: var(--button-color);
+}

app/renderer/css/fonts.css

@@ -0,0 +1,12 @@
+@font-face {
+  font-family: "Material Icons";
+  font-style: normal;
+  font-weight: 400;
+  src: local("Material Icons"), local("MaterialIcons-Regular"),
+    url("../fonts/MaterialIcons-Regular.ttf") format("truetype");
+}
+
+@font-face {
+  font-family: Montserrat;
+  src: url("../fonts/Montserrat-Regular.ttf") format("truetype");
+}

app/renderer/css/main.css

@@ -16,9 +16,9 @@ body {
 }
 
 .toggle-sidebar {
-    background: rgba(34, 44, 49, 1.000);
+  background: rgb(34 44 49 / 100%);
   width: 54px;
-    padding: 27px 0 20px 0;
+  padding: 27px 0 20px;
   justify-content: space-between;
   display: flex;
   flex-direction: column;
@@ -47,31 +47,23 @@ body {
   overflow-y: hidden;
 }
 
-#view-controls-container:hover {
-    overflow-y: overlay;
-}
-
 #view-controls-container::-webkit-scrollbar {
   width: 4px;
 }
 
 #view-controls-container::-webkit-scrollbar-track {
-    box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
+  box-shadow: inset 0 0 6px rgb(0 0 0 / 30%);
 }
 
 #view-controls-container::-webkit-scrollbar-thumb {
-    background-color: rgba(169, 169, 169, 1.000);
+  background-color: rgb(169 169 169 / 100%);
-    outline: 1px solid rgba(169, 169, 169, 1.000);
+  outline: 1px solid rgb(169 169 169 / 100%);
 }
 
-@font-face {
+#view-controls-container:hover {
-    font-family: 'Material Icons';
+  overflow-y: overlay;
-    font-style: normal;
-    font-weight: 400;
-    src: local('Material Icons'), local('MaterialIcons-Regular'), url(../fonts/MaterialIcons-Regular.ttf) format('truetype');
 }
 
-
 /*******************
   *   Left Sidebar  *
   *******************/
@@ -83,9 +75,10 @@ body {
 }
 
 .material-icons {
-    font-family: 'Material Icons';
+  font-family: "Material Icons";
   font-weight: normal;
   font-style: normal;
+
   /* Preferred icon size */
   font-size: 24px;
   display: inline-block;
@@ -95,10 +88,12 @@ body {
   word-wrap: normal;
   white-space: nowrap;
   direction: ltr;
+
   /* Support for all WebKit browsers. */
   -webkit-font-smoothing: antialiased;
+
   /* Support for Safari and Chrome. */
-    text-rendering: optimizeLegibility;
+  text-rendering: optimizelegibility;
 }
 
 #actions-container {
@@ -119,12 +114,23 @@ body {
 }
 
 .action-button i {
-    color: rgba(108, 133, 146, 1.000);
+  color: rgb(108 133 146 / 100%);
   font-size: 28px;
 }
 
 .action-button:hover i {
-    color: rgba(152, 169, 179, 1.000);
+  color: rgb(152 169 179 / 100%);
+}
+
+.action-button.active {
+  /* background-color: rgba(255, 255, 255, 0.25); */
+  background-color: rgb(239 239 239 / 100%);
+  opacity: 0.9;
+  padding-right: 14px;
+}
+
+.action-button.active i {
+  color: rgb(28 38 43 / 100%);
 }
 
 .action-button.disable {
@@ -136,22 +142,7 @@ body {
 }
 
 .action-button.disable:hover i {
-    color: rgba(108, 133, 146, 1.000);
+  color: rgb(108 133 146 / 100%);
-}
-
-.action-button.active {
-    /* background-color: rgba(255, 255, 255, 0.25); */
-    background-color: rgba(239, 239, 239, 1.000);
-    opacity: 0.9;
-    padding-right: 14px;
-}
-
-.action-button.active i {
-    color: rgba(28, 38, 43, 1.000);
-}
-
-.tab:first-child {
-    margin-top: 9px;
 }
 
 .tab {
@@ -164,6 +155,10 @@ body {
   width: 100%;
 }
 
+.tab:first-child {
+  margin-top: 9px;
+}
+
 .tab .server-icons {
   width: 35px;
   vertical-align: top;
@@ -177,7 +172,7 @@ body {
   margin-top: 5px;
   z-index: 11;
   line-height: 31px;
-    color: rgba(238, 238, 238, 1.000);
+  color: rgb(238 238 238 / 100%);
   text-align: center;
   overflow: hidden;
   opacity: 0.6;
@@ -185,10 +180,10 @@ body {
 }
 
 .server-tab .alt-icon {
-    font-family: Verdana;
+  font-family: Verdana, sans-serif;
   font-weight: 600;
   font-size: 22px;
-    border: 2px solid rgba(34, 44, 49, 1.000);
+  border: 2px solid rgb(34 44 49 / 100%);
   margin-left: 17%;
   width: 35px;
   border-radius: 4px;
@@ -198,6 +193,11 @@ body {
   opacity: 0.8;
 }
 
+.tab.active .server-tab {
+  opacity: 1;
+  background-color: rgb(100 132 120 / 100%);
+}
+
 .tab.functional-tab {
   height: 46px;
   padding: 0;
@@ -206,7 +206,7 @@ body {
 .tab.functional-tab.active .server-tab {
   padding: 2px 0;
   height: 40px;
-    background-color: rgba(255, 255, 255, 0.25);
+  background-color: rgb(255 255 255 / 25%);
 }
 
 .tab.functional-tab .server-tab i {
@@ -214,25 +214,19 @@ body {
   line-height: 36px;
 }
 
-.tab.active .server-tab {
-    opacity: 1;
-    background-color: rgba(100, 132, 120, 1.000);
-}
-
 .tab .server-tab-badge.active {
   border-radius: 9px;
   min-width: 11px;
   padding: 0 3px;
   height: 17px;
-    background-color: rgba(244, 67, 54, 1.000);
+  background-color: rgb(244 67 54 / 100%);
   font-size: 10px;
   font-family: sans-serif;
   position: absolute;
-    right: 5px;
   z-index: 15;
   top: 6px;
   float: right;
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
   text-align: center;
   line-height: 17px;
   display: block;
@@ -260,7 +254,7 @@ body {
 }
 
 .tab .server-tab-shortcut {
-    color: rgba(100, 132, 120, 1.000);
+  color: rgb(100 132 120 / 100%);
   font-size: 12px;
   text-align: center;
   font-family: sans-serif;
@@ -275,6 +269,7 @@ body {
   from {
     transform: rotate(0);
   }
+
   to {
     transform: rotate(-360deg);
   }
@@ -295,7 +290,7 @@ body {
   content: "";
   position: absolute;
   z-index: 1;
-    background: rgba(255, 255, 255, 1.000) url(../img/ic_loading.gif) no-repeat;
+  background: rgb(255 255 255 / 100%) url("../img/ic_loading.gif") no-repeat;
   background-size: 60px 60px;
   background-position: center;
   width: 100%;
@@ -304,38 +299,27 @@ body {
 
 /* When the active webview is loaded */
 #webviews-container.loaded::before {
-    opacity: 0;
   z-index: -1;
   visibility: hidden;
 }
 
-webview {
+webview,
-    /* transition: opacity 0.3s ease-in; */
+.functional-view {
-    flex-grow: 1;
   position: absolute;
   width: 100%;
   height: 100%;
   flex-grow: 1;
-    display: flex;
+  visibility: hidden;
-    flex-direction: column;
 }
 
-webview.onload {
+webview.active,
-    transition: opacity 1s cubic-bezier(0.95, 0.05, 0.795, 0.035);
+.functional-view.active {
-}
-
-webview.active {
-    opacity: 1;
   z-index: 1;
   visibility: visible;
 }
 
-webview.disabled {
-    opacity: 0;
-}
-
 webview.focus {
-    outline: 0px solid transparent;
+  outline: 0 solid transparent;
 }
 
 /* Tooltip styling */
@@ -346,13 +330,13 @@ webview.focus {
 #reload-tooltip,
 #setting-tooltip {
   font-family: sans-serif;
-    background: rgba(34, 44, 49, 1.000);
+  background: rgb(34 44 49 / 100%);
   margin-left: 48px;
   padding: 6px 8px;
   position: absolute;
-    margin-top: 0px;
+  margin-top: 0;
   z-index: 1000;
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
   border-radius: 4px;
   text-align: center;
   width: 55px;
@@ -367,7 +351,7 @@ webview.focus {
   content: " ";
   border-top: 8px solid transparent;
   border-bottom: 8px solid transparent;
-    border-right: 8px solid rgba(34, 44, 49, 1.000);
+  border-right: 8px solid rgb(34 44 49 / 100%);
   position: absolute;
   top: 7px;
   right: 68px;
@@ -375,14 +359,14 @@ webview.focus {
 
 #add-server-tooltip,
 .server-tooltip {
-    font-family: 'arial';
+  font-family: arial, sans-serif;
-    background: rgba(34, 44, 49, 1.000);
+  background: rgb(34 44 49 / 100%);
   left: 56px;
   padding: 10px 20px;
   position: fixed;
   margin-top: 11px;
   z-index: 5000 !important;
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
   border-radius: 4px;
   text-align: center;
   width: max-content;
@@ -394,7 +378,7 @@ webview.focus {
   content: " ";
   border-top: 8px solid transparent;
   border-bottom: 8px solid transparent;
-    border-right: 8px solid rgba(34, 44, 49, 1.000);
+  border-right: 8px solid rgb(34 44 49 / 100%);
   position: absolute;
   top: 10px;
   left: -5px;
@@ -406,14 +390,14 @@ webview.focus {
   position: absolute;
   width: 24px;
   height: 24px;
-    background: rgba(34, 44, 49, 1.000);
+  background: rgb(34 44 49 / 100%);
   border-radius: 20px;
   cursor: pointer;
-    box-shadow: rgba(153, 153, 153, 1.000) 1px 1px;
+  box-shadow: rgb(153 153 153 / 100%) 1px 1px;
 }
 
 #collapse-button i {
-    color: rgba(239, 239, 239, 1.000);
+  color: rgb(239 239 239 / 100%);
 }
 
 #main-container {
@@ -422,26 +406,25 @@ webview.focus {
   width: 100%;
   position: relative;
   flex-grow: 1;
-    flex-basis: 0px;
+  flex-basis: 0;
 }
 
 .hidden {
   display: none !important;
 }
 
-
 /* Full screen Popup container  */
 
 .popup .popuptext {
   visibility: hidden;
-    background-color: rgba(85, 85, 85, 1.000);
+  background-color: rgb(85 85 85 / 100%);
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
   text-align: center;
   border-radius: 6px;
   padding: 9px 0;
   position: absolute;
   z-index: 1000;
-    font-family: arial;
+  font-family: arial, sans-serif;
   width: 240px;
   top: 15px;
   height: 20px;
@@ -450,14 +433,15 @@ webview.focus {
 
 .popup .show {
   visibility: visible;
-    animation: cssAnimation 0s ease-in 5s forwards;
+  animation: full-screen-popup 0s ease-in 1s forwards;
   animation-fill-mode: forwards;
 }
 
-@keyframes cssAnimation {
+@keyframes full-screen-popup {
   from {
     opacity: 0;
   }
+
   to {
     width: 0;
     height: 0;
@@ -465,26 +449,3 @@ webview.focus {
     opacity: 1;
   }
 }
-
-send-feedback {
-    width: 60%;
-    height: 85%;
-}
-
-#feedback-modal {
-    display: none;
-    position: absolute;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    background-color: rgba(68, 67, 67, 0.81);
-    align-items: center;
-    justify-content: center;
-    z-index: 2;
-    transition: all 1s ease-out;
-}
-
-#feedback-modal.show {
-    display: flex;
-}

app/renderer/css/network.css

@@ -3,8 +3,8 @@ body {
   margin: 0;
   cursor: default;
   font-size: 14px;
-    color: rgba(51, 51, 51, 1.000);
+  color: rgb(51 51 51 / 100%);
-    background: rgba(255, 255, 255, 1.000);
+  background: rgb(255 255 255 / 100%);
   user-select: none;
 }
 
@@ -45,8 +45,8 @@ body {
 
 .button {
   font-size: 16px;
-    background: rgba(0, 150, 136, 1.000);
+  background: rgb(0 150 136 / 100%);
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
   width: 96px;
   height: 32px;
   border-radius: 5px;

app/renderer/css/preference.css

@@ -1,31 +1,30 @@
-html,
+:host {
-body {
+  contain: strict;
-    height: 100%;
+  display: flow-root;
-    margin: 0;
   cursor: default;
   user-select: none;
   font-family: menu, "Helvetica Neue", sans-serif;
   -webkit-font-smoothing: antialiased;
   font-size: 14px;
-    background: rgba(239, 239, 239, 1.000);
+  background: rgb(239 239 239 / 100%);
-    letter-spacing: -.08px;
+  letter-spacing: -0.08px;
   line-height: 18px;
-    color: rgba(139, 142, 143, 1.000);
+  color: rgb(139 142 143 / 100%);
 }
 
 kbd {
   display: inline-block;
-    border: 1px solid rgba(204, 204, 204, 1.000);
+  border: 1px solid rgb(204 204 204 / 100%);
   border-radius: 4px;
   font-size: 15px;
-    font-family: Courier New, Courier, monospace;
+  font-family: "Courier New", Courier, monospace;
   font-weight: bold;
   white-space: nowrap;
-    background-color: rgba(247, 247, 247, 1.000);
+  background-color: rgb(247 247 247 / 100%);
-    color: rgba(51, 51, 51, 1.000);
+  color: rgb(51 51 51 / 100%);
   margin: 0 0.1em;
   padding: 0.3em 0.8em;
-    text-shadow: 0 1px 0 rgba(255, 255, 255, 1.000);
+  text-shadow: 0 1px 0 rgb(255 255 255 / 100%);
   line-height: 1.4;
 }
 
@@ -33,7 +32,7 @@ table,
 th,
 td {
   border-collapse: collapse;
-    color: rgba(56, 52, 48, 1.000);
+  color: rgb(56 52 48 / 100%);
 }
 
 table {
@@ -42,14 +41,6 @@ table {
   margin-bottom: 18px;
 }
 
-table tr:nth-child(even) {
-    background-color: rgba(250, 250, 250, 1.000);
-}
-
-table tr:nth-child(odd) {
-    background-color: rgba(255, 255, 255, 1.000);
-}
-
 td {
   padding: 5px;
 }
@@ -59,22 +50,11 @@ td:nth-child(odd) {
   width: 50%;
 }
 
-@font-face {
-    font-family: 'Material Icons';
-    font-style: normal;
-    font-weight: 400;
-    src: local('Material Icons'), local('MaterialIcons-Regular'), url(../fonts/MaterialIcons-Regular.ttf) format('truetype');
-}
-
-@font-face {
-    font-family: 'Montserrat';
-    src: url(../fonts/Montserrat-Regular.ttf) format('truetype');
-}
-
 .material-icons {
-    font-family: 'Material Icons';
+  font-family: "Material Icons";
   font-weight: normal;
   font-style: normal;
+
   /* Preferred icon size */
   font-size: 24px;
   display: inline-block;
@@ -84,16 +64,18 @@ td:nth-child(odd) {
   word-wrap: normal;
   white-space: nowrap;
   direction: ltr;
+
   /* Support for all WebKit browsers. */
   -webkit-font-smoothing: antialiased;
+
   /* Support for Safari and Chrome. */
-    text-rendering: optimizeLegibility;
+  text-rendering: optimizelegibility;
 }
 
 #content {
-    display: flex;
+  display: flex !important;
   height: 100%;
-    font-family: 'Montserrat';
+  font-family: Montserrat, sans-serif;
 }
 
 #sidebar {
@@ -103,7 +85,7 @@ td:nth-child(odd) {
   display: flex;
   flex-direction: column;
   font-size: 16px;
-    background: rgba(242, 242, 242, 1.000);
+  background: rgb(242 242 242 / 100%);
 }
 
 #nav-container {
@@ -112,34 +94,35 @@ td:nth-child(odd) {
 
 .nav {
   padding: 7px 0;
-    color: rgba(153, 153, 153, 1.000);
+  color: rgb(153 153 153 / 100%);
   cursor: pointer;
 }
 
 .nav.active {
-    color: rgba(78, 191, 172, 1.000);
+  color: rgb(78 191 172 / 100%);
   cursor: default;
   position: relative;
 }
 
 .nav.active::before {
-    background: rgba(70, 78, 90, 1.000);
+  background: rgb(70 78 90 / 100%);
   width: 3px;
   height: 18px;
   position: absolute;
   left: -8px;
-    content: '';
+  content: "";
 }
 
 /* We don't want to show this in nav item since we have the + button for adding an Organization */
 
+/* stylelint-disable-next-line selector-id-pattern */
 #nav-AddServer {
   display: none;
 }
 
 #settings-header {
   font-size: 22px;
-    color: rgba(34, 44, 49, 1.000);
+  color: rgb(34 44 49 / 100%);
   font-weight: bold;
   text-transform: uppercase;
 }
@@ -159,19 +142,19 @@ td:nth-child(odd) {
 
 .title {
   font-weight: 500;
-    color: rgba(34, 44, 49, 1.000);
+  color: rgb(34 44 49 / 100%);
 }
 
 .page-title {
-    color: rgba(34, 44, 49, 1.000);
+  color: rgb(34 44 49 / 100%);
   font-size: 15px;
   font-weight: bold;
-    padding: 4px 0 6px 0;
+  padding: 4px 0 6px;
 }
 
 .add-server-info-row {
   display: flex;
-    margin: 8px 0 0 0;
+  margin: 8px 0 0;
 }
 
 .add-server-info-right {
@@ -180,9 +163,9 @@ td:nth-child(odd) {
 }
 
 .sub-title {
-    padding: 4px 0 6px 0;
+  padding: 4px 0 6px;
   font-weight: bold;
-    color: rgba(97, 97, 97, 1.000);
+  color: rgb(97 97 97 / 100%);
 }
 
 img.server-info-icon {
@@ -209,7 +192,7 @@ img.server-info-icon {
 
 .server-info-row {
   display: inline-block;
-    margin: 5px 0 0 0;
+  margin: 5px 0 0;
 }
 
 .server-info-left .server-info-row {
@@ -249,18 +232,18 @@ img.server-info-icon {
   font-size: 14px;
   border-radius: 4px;
   padding: 13px;
-    border: rgba(237, 237, 237, 1.000) 2px solid;
+  border: rgb(237 237 237 / 100%) 2px solid;
   outline-width: 0;
   background: transparent;
   max-width: 450px;
 }
 
 .setting-input-value:focus {
-    border: rgba(78, 191, 172, 1.000) 2px solid;
+  border: rgb(78 191 172 / 100%) 2px solid;
 }
 
 .invalid-input-value:focus {
-    border: rgba(239, 83, 80, 1) 2px solid;
+  border: rgb(239 83 80 / 100%) 2px solid;
 }
 
 .manual-proxy-block {
@@ -270,7 +253,7 @@ img.server-info-icon {
 .actions-container {
   display: flex;
   font-size: 14px;
-    color: rgba(35, 93, 58, 1.000);
+  color: rgb(35 93 58 / 100%);
   vertical-align: middle;
   margin: 10px 0;
   flex-wrap: wrap;
@@ -298,26 +281,26 @@ img.server-info-icon {
   cursor: pointer;
 }
 
-.action.disabled:hover {
+.action.disabled {
-    cursor: default;
+  color: rgb(153 153 153 / 100%);
 }
 
-.action.disabled {
+.action.disabled:hover {
-    color: rgba(153, 153, 153, 1.000);
+  cursor: default;
 }
 
 .settings-card {
   display: flex;
   flex-wrap: wrap;
   padding: 12px 30px;
-    margin: 10px 0 20px 0;
+  margin: 10px 0 20px;
-    background: rgba(255, 255, 255, 1.000);
+  background: rgb(255 255 255 / 100%);
   width: 80%;
   transition: all 0.2s;
 }
 
 .settings-card:hover {
-    box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 0px 0px rgba(0, 0, 0, 0.12);
+  box-shadow: 0 2px 5px 0 rgb(0 0 0 / 16%), 0 2px 0 0 rgb(0 0 0 / 12%);
 }
 
 .hidden {
@@ -326,11 +309,11 @@ img.server-info-icon {
 }
 
 .red {
-    color: rgb(240, 148, 148);
+  color: rgb(240 148 148);
-    background: rgba(255, 255, 255, 1.000);
+  background: rgb(255 255 255 / 100%);
   border-radius: 4px;
   display: inline-block;
-    border: 2px solid rgb(240, 148, 148);
+  border: 2px solid rgb(240 148 148);
   padding: 10px;
   width: 100px;
   cursor: pointer;
@@ -342,13 +325,13 @@ img.server-info-icon {
 }
 
 .red:hover {
-    background-color: rgb(240, 148, 148);
+  background-color: rgb(240 148 148);
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
 }
 
 .green {
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
-    background: rgba(78, 191, 172, 1.000);
+  background: rgb(78 191 172 / 100%);
   border-radius: 4px;
   display: inline-block;
   border: none;
@@ -363,8 +346,8 @@ img.server-info-icon {
 }
 
 .green:hover {
-    background-color: rgba(60, 159, 141, 1.000);
+  background-color: rgb(60 159 141 / 100%);
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
 }
 
 .w-150 {
@@ -376,9 +359,9 @@ img.server-info-icon {
 }
 
 .grey {
-    color: rgba(158, 158, 158, 1.000);
+  color: rgb(158 158 158 / 100%);
-    background: rgba(250, 250, 250, 1.000);
+  background: rgb(250 250 250 / 100%);
-    border: 1px solid rgba(158, 158, 158, 1.000);
+  border: 1px solid rgb(158 158 158 / 100%);
 }
 
 .setting-row {
@@ -389,8 +372,12 @@ img.server-info-icon {
   margin: 6px;
 }
 
+#note {
+  font-size: 10px;
+}
+
 .code {
-    font-family: Courier New, Courier, monospace;
+  font-family: "Courier New", Courier, monospace;
 }
 
 i.open-tab-button {
@@ -409,12 +396,12 @@ i.open-tab-button {
         .action class will add extra margin to right which
         we don't want for a button; the extra margin is intended for radio buttons
     */
-    margin-right: 0px;
+  margin-right: 0;
 }
 
 .selected-css-path,
 .download-folder-path {
-    background: rgba(238, 238, 238, 1.000);
+  background: rgb(238 238 238 / 100%);
   padding: 5px 10px;
   margin-right: 10px;
   display: flex;
@@ -431,7 +418,7 @@ i.open-tab-button {
 }
 
 #new-org-button {
-    margin: 30px 0px 30px 0px;
+  margin: 30px 0;
 }
 
 #create-organization-container {
@@ -463,7 +450,7 @@ i.open-tab-button {
 }
 
 .disallowed:hover {
-    background-color: rgba(241, 241, 241, 1.000);
+  background-color: rgb(241 241 241 / 100%);
   cursor: not-allowed;
 }
 
@@ -471,7 +458,7 @@ input.toggle-round + label {
   padding: 2px;
   width: 50px;
   height: 25px;
-    background-color: rgba(221, 221, 221, 1.000);
+  background-color: rgb(221 221 221 / 100%);
   border-radius: 25px;
 }
 
@@ -486,27 +473,27 @@ input.toggle-round + label::after {
 }
 
 input.toggle-round + label::before {
-    background-color: rgba(241, 241, 241, 1.000);
+  background-color: rgb(241 241 241 / 100%);
   border-radius: 25px;
   top: 0;
-    right: 0px;
+  right: 0;
-    left: 0px;
+  left: 0;
-    bottom: 0px;
+  bottom: 0;
 }
 
 input.toggle-round + label::after {
   width: 25px;
   height: 25px;
-    background-color: rgba(255, 255, 255, 1.000);
+  background-color: rgb(255 255 255 / 100%);
   border-radius: 100%;
 }
 
 input.toggle-round:checked + label::before {
-    background-color: rgba(78, 191, 172, 1.000);
+  background-color: rgb(78 191 172 / 100%);
   top: 0;
-    right: 0px;
+  right: 0;
-    left: 0px;
+  left: 0;
-    bottom: 0px;
+  bottom: 0;
 }
 
 input.toggle-round:checked + label::after {
@@ -525,18 +512,23 @@ input.toggle-round:checked + label::after {
   margin: auto;
   width: 100%;
   height: 100%;
+
   /* background: rgba(61, 64, 67, 15); */
-    background: linear-gradient(35deg, rgba(0, 59, 82, 1.000), rgba(69, 181, 155, 1.000));
+  background: linear-gradient(
+    35deg,
+    rgb(0 59 82 / 100%),
+    rgb(69 181 155 / 100%)
+  );
   overflow: auto;
 }
 
 /* Modal Content */
 
 .modal-container {
-    background-color: rgba(244, 247, 248, 1.000);
+  background-color: rgb(244 247 248 / 100%);
   margin: auto;
   padding: 57px;
-    border: rgba(218, 225, 227, 1.000) 1px solid;
+  border: rgb(218 225 227 / 100%) 1px solid;
   width: 550px;
   height: 370px;
   border-radius: 4px;
@@ -550,7 +542,7 @@ input.toggle-round:checked + label::after {
 .divider {
   margin-bottom: 30px;
   margin-top: 30px;
-    color: rgba(125, 135, 138, 1.000);
+  color: rgb(125 135 138 / 100%);
 }
 
 .divider hr {
@@ -581,8 +573,8 @@ input.toggle-round:checked + label::after {
   margin: auto;
   align-items: center;
   text-align: center;
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
-    background: rgba(78, 191, 172, 1.000);
+  background: rgb(78 191 172 / 100%);
   border-color: none;
   border: none;
   width: 98%;
@@ -592,11 +584,11 @@ input.toggle-round:checked + label::after {
 }
 
 .server-center button:hover {
-    background: rgba(50, 149, 136, 1.000);
+  background: rgb(50 149 136 / 100%);
 }
 
 .server-center button:focus {
-    background: rgba(50, 149, 136, 1.000);
+  background: rgb(50 149 136 / 100%);
 }
 
 .certificates-card {
@@ -618,10 +610,6 @@ input.toggle-round:checked + label::after {
   max-width: 100%;
 }
 
-#add-certificate-button {
-    margin: 10px 10px 10px 37px;
-}
-
 .tip {
   background: none;
   padding: 0;
@@ -649,7 +637,7 @@ input.toggle-round:checked + label::after {
   padding-top: 15px;
   align-items: center;
   text-align: center;
-    color: rgb(78, 191, 172);
+  color: rgb(78 191 172);
   width: 98%;
   height: 46px;
   cursor: pointer;
@@ -663,15 +651,39 @@ i.open-network-button {
 }
 
 /* responsive grid */
+@media (min-width: 500px) and (max-width: 720px) {
+  #new-server-container {
+    padding-left: 0;
+    width: 60vw;
+    padding-right: 4vh;
+  }
+
+  .page-title {
+    width: 60vw;
+  }
+}
+
+@media (max-width: 500px) {
+  #new-server-container {
+    padding-left: 0;
+    width: 54%;
+  }
+
+  .page-title {
+    width: 54%;
+  }
+}
 
 @media (max-width: 650px) {
   .selected-css-path,
   .download-folder-path {
     margin-right: 15px;
   }
+
   #css-delete-action {
     margin-left: 10px;
   }
+
   #css-delete-action span {
     display: none;
   }
@@ -683,27 +695,28 @@ i.open-network-button {
     padding: 40px;
     min-width: 300px;
   }
+
   .server-center button {
     margin-right: -12px;
     width: 100%;
   }
+
   .divider {
     margin-right: -8px;
   }
+
   .divider hr {
     margin-left: 6px;
     margin-right: 6px;
     width: 43%;
   }
-    #new-server-container {
-        padding-left: 0px;
-    }
 }
 
 @media (max-width: 600px) {
   .divider {
     margin-left: 4%;
   }
+
   .divider hr {
     margin-left: 2px;
     margin-right: 2px;
@@ -716,10 +729,12 @@ i.open-network-button {
     flex-direction: column;
     align-items: center;
   }
+
   .server-info-right {
     flex-direction: column;
     align-items: center;
   }
+
   .action {
     margin-top: 10px;
   }
@@ -728,9 +743,20 @@ i.open-network-button {
 .lang-menu {
   font-size: 13px;
   font-weight: bold;
-    background: rgba(78, 191, 172, 1.000);
+  background: rgb(78 191 172 / 100%);
   width: 100px;
   height: 38px;
-    color: rgba(255, 255, 255, 1.000);
+  color: rgb(255 255 255 / 100%);
-    border-color: rgba(0, 0, 0, 0);
+  border-color: rgb(0 0 0 / 0%);
+}
+
+/* stylelint-disable-next-line selector-class-pattern */
+.tagify__input {
+  min-width: 130px !important;
+}
+
+/* stylelint-disable-next-line selector-class-pattern */
+.tagify__input::before {
+  top: 0;
+  bottom: 0;
 }

app/renderer/js/clipboard-decrypter.ts

@@ -0,0 +1,89 @@
+import {clipboard} from "electron/common";
+import {Buffer} from "node:buffer";
+import crypto from "node: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 interface ClipboardDecrypter {
+  version: number;
+  key: Uint8Array;
+  pasted: Promise<string>;
+}
+
+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,7 +1,12 @@
-export default class BaseComponent {
+import type {Html} from "../../../common/html";
-	generateNodeFromTemplate(template: string): Element | null {
+
-		const wrapper = document.createElement('div');
+export function generateNodeFromHtml(html: Html): Element {
-		wrapper.innerHTML = template;
+  const wrapper = document.createElement("div");
-		return wrapper.firstElementChild;
+  wrapper.innerHTML = html.html;
+
+  if (wrapper.firstElementChild === null) {
+    throw new Error("No element found in HTML");
   }
+
+  return wrapper.firstElementChild;
 }

app/renderer/js/components/context-menu.ts

@@ -0,0 +1,149 @@
+import {clipboard} from "electron/common";
+import type {WebContents} from "electron/main";
+import type {
+  ContextMenuParams,
+  MenuItemConstructorOptions,
+} from "electron/renderer";
+import process from "node:process";
+
+import {Menu} from "@electron/remote";
+
+import * as t from "../../../common/translation-util";
+
+export const contextMenu = (
+  webContents: WebContents,
+  event: Event,
+  props: ContextMenuParams,
+) => {
+  const isText = props.selectionText !== "";
+  const isLink = props.linkURL !== "";
+  const linkUrl = isLink ? new URL(props.linkURL) : undefined;
+
+  const makeSuggestion = (suggestion: string) => ({
+    label: suggestion,
+    visible: true,
+    async click() {
+      await webContents.insertText(suggestion);
+    },
+  });
+
+  let menuTemplate: MenuItemConstructorOptions[] = [
+    {
+      label: t.__("Add to Dictionary"),
+      visible: props.isEditable && isText && props.misspelledWord.length > 0,
+      click(_item) {
+        webContents.session.addWordToSpellCheckerDictionary(
+          props.misspelledWord,
+        );
+      },
+    },
+    {
+      type: "separator",
+      visible: props.isEditable && isText && props.misspelledWord.length > 0,
+    },
+    {
+      label: `${t.__("Look Up")} "${props.selectionText}"`,
+      visible: process.platform === "darwin" && isText,
+      click(_item) {
+        webContents.showDefinitionForSelection();
+      },
+    },
+    {
+      type: "separator",
+      visible: process.platform === "darwin" && isText,
+    },
+    {
+      label: t.__("Cut"),
+      visible: isText,
+      enabled: props.isEditable,
+      accelerator: "CommandOrControl+X",
+      click(_item) {
+        webContents.cut();
+      },
+    },
+    {
+      label: t.__("Copy"),
+      accelerator: "CommandOrControl+C",
+      enabled: props.editFlags.canCopy,
+      click(_item) {
+        webContents.copy();
+      },
+    },
+    {
+      label: t.__("Paste"), // Bug: Paste replaces text
+      accelerator: "CommandOrControl+V",
+      enabled: props.isEditable,
+      click() {
+        webContents.paste();
+      },
+    },
+    {
+      type: "separator",
+    },
+    {
+      label:
+        linkUrl?.protocol === "mailto:"
+          ? t.__("Copy Email Address")
+          : t.__("Copy Link"),
+      visible: isLink,
+      click(_item) {
+        clipboard.write({
+          bookmark: props.linkText,
+          text:
+            linkUrl?.protocol === "mailto:" ? linkUrl.pathname : props.linkURL,
+        });
+      },
+    },
+    {
+      label: t.__("Copy Image"),
+      visible: props.mediaType === "image",
+      click(_item) {
+        webContents.copyImageAt(props.x, props.y);
+      },
+    },
+    {
+      label: t.__("Copy Image URL"),
+      visible: props.mediaType === "image",
+      click(_item) {
+        clipboard.write({
+          bookmark: props.srcURL,
+          text: props.srcURL,
+        });
+      },
+    },
+    {
+      type: "separator",
+      visible: isLink || props.mediaType === "image",
+    },
+    {
+      label: t.__("Services"),
+      visible: process.platform === "darwin",
+      role: "services",
+    },
+  ];
+
+  if (props.misspelledWord) {
+    if (props.dictionarySuggestions.length > 0) {
+      const suggestions: MenuItemConstructorOptions[] =
+        props.dictionarySuggestions.map((suggestion: string) =>
+          makeSuggestion(suggestion),
+        );
+      menuTemplate = [...suggestions, ...menuTemplate];
+    } else {
+      menuTemplate.unshift({
+        label: t.__("No Suggestion Found"),
+        enabled: false,
+      });
+    }
+  }
+  // Hide the invisible separators on Linux and Windows
+  // Electron has a bug which ignores visible: false parameter for separator menuitems. So we remove them here.
+  // https://github.com/electron/electron/issues/5869
+  // https://github.com/electron/electron/issues/6906
+
+  const filteredMenuTemplate = menuTemplate.filter(
+    (menuItem) => menuItem.visible ?? true,
+  );
+  const menu = Menu.buildFromTemplate(filteredMenuTemplate);
+  menu.popup();
+};

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

@@ -1,45 +1,72 @@
-import Tab, { TabProps } from './tab';
+import type {Html} from "../../../common/html";
+import {html} from "../../../common/html";
+
+import {generateNodeFromHtml} from "./base";
+import type {TabProps} from "./tab";
+import Tab from "./tab";
+
+export interface FunctionalTabProps extends TabProps {
+  $view: Element;
+}
 
 export default class FunctionalTab extends Tab {
-	$closeButton: Element;
+  $view: Element;
-	template(): string {
+  $el: Element;
-		return `<div class="tab functional-tab" data-tab-id="${this.props.tabIndex}">
+  $closeButton?: Element;
+
+  constructor({$view, ...props}: FunctionalTabProps) {
+    super(props);
+
+    this.$view = $view;
+    this.$el = generateNodeFromHtml(this.templateHtml());
+    if (this.props.name !== "Settings") {
+      this.props.$root.append(this.$el);
+      this.$closeButton = this.$el.querySelector(".server-tab-badge")!;
+      this.registerListeners();
+    }
+  }
+
+  override async activate(): Promise<void> {
+    await super.activate();
+    this.$view.classList.add("active");
+  }
+
+  override async deactivate(): Promise<void> {
+    await super.deactivate();
+    this.$view.classList.remove("active");
+  }
+
+  override async destroy(): Promise<void> {
+    await super.destroy();
+    this.$view.remove();
+  }
+
+  templateHtml(): Html {
+    return html`
+      <div class="tab functional-tab" data-tab-id="${this.props.tabIndex}">
         <div class="server-tab-badge close-button">
           <i class="material-icons">close</i>
         </div>
         <div class="server-tab">
           <i class="material-icons">${this.props.materialIcon}</i>
         </div>
-				</div>`;
+      </div>
+    `;
   }
 
-	constructor(props: TabProps) {
+  override registerListeners(): void {
-		super(props);
-		this.init();
-	}
-
-	init(): void {
-		this.$el = this.generateNodeFromTemplate(this.template());
-		if (this.props.name !== 'Settings') {
-			this.props.$root.append(this.$el);
-			this.$closeButton = this.$el.querySelectorAll('.server-tab-badge')[0];
-			this.registerListeners();
-		}
-	}
-
-	registerListeners(): void {
     super.registerListeners();
 
-		this.$el.addEventListener('mouseover', () => {
+    this.$el.addEventListener("mouseover", () => {
-			this.$closeButton.classList.add('active');
+      this.$closeButton?.classList.add("active");
     });
 
-		this.$el.addEventListener('mouseout', () => {
+    this.$el.addEventListener("mouseout", () => {
-			this.$closeButton.classList.remove('active');
+      this.$closeButton?.classList.remove("active");
     });
 
-		this.$closeButton.addEventListener('click', (event: Event) => {
+    this.$closeButton?.addEventListener("click", (event: Event) => {
-			this.props.onDestroy();
+      this.props.onDestroy?.();
       event.stopPropagation();
     });
   }

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

@@ -1,56 +0,0 @@
-import { ipcRenderer, remote } from 'electron';
-
-import * as LinkUtil from '../utils/link-util';
-import * as ConfigUtil from '../utils/config-util';
-import type WebView from './webview';
-
-const { shell, app } = remote;
-
-const dingSound = new Audio('../resources/sounds/ding.ogg');
-
-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')}`);
-
-	if (LinkUtil.isUploadsUrl(this.props.url, url)) {
-		ipcRenderer.send('downloadFile', url.href, downloadPath);
-		ipcRenderer.once('downloadFileCompleted', (_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
-			});
-
-			// Play sound to indicate download complete
-			if (!ConfigUtil.getConfigItem('silent')) {
-				dingSound.play();
-			}
-
-			downloadNotification.addEventListener('click', () => {
-				// Reveal file in download folder
-				shell.showItemInFolder(filePath);
-			});
-			ipcRenderer.removeAllListeners('downloadFileFailed');
-		});
-
-		ipcRenderer.once('downloadFileFailed', () => {
-			// 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)
-			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);
-			}
-			ipcRenderer.removeAllListeners('downloadFileCompleted');
-		});
-	} else {
-		LinkUtil.openBrowser(url);
-	}
-}

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

@@ -1,63 +1,81 @@
-import { ipcRenderer } from 'electron';
+import process from "node:process";
 
-import Tab, { TabProps } from './tab';
+import type {Html} from "../../../common/html";
-import * as SystemUtil from '../utils/system-util';
+import {html} from "../../../common/html";
+import {ipcRenderer} from "../typed-ipc-renderer";
+
+import {generateNodeFromHtml} from "./base";
+import type {TabProps} from "./tab";
+import Tab from "./tab";
+import type WebView from "./webview";
+
+export interface ServerTabProps extends TabProps {
+  webview: Promise<WebView>;
+}
 
 export default class ServerTab extends Tab {
+  webview: Promise<WebView>;
+  $el: Element;
   $badge: Element;
 
-	template(): string {
+  constructor({webview, ...props}: ServerTabProps) {
-		return `<div class="tab" data-tab-id="${this.props.tabIndex}">
-					<div class="server-tooltip" style="display:none">${this.props.name}</div>
-					<div class="server-tab-badge"></div>
-					<div class="server-tab">
-					<img class="server-icons" src='${this.props.icon}'/>
-					</div>
-					<div class="server-tab-shortcut">${this.generateShortcutText()}</div>
-				</div>`;
-	}
-
-	constructor(props: TabProps) {
     super(props);
-		this.init();
-	}
 
-	init(): void {
+    this.webview = webview;
-		this.$el = this.generateNodeFromTemplate(this.template());
+    this.$el = generateNodeFromHtml(this.templateHtml());
     this.props.$root.append(this.$el);
     this.registerListeners();
-		this.$badge = this.$el.querySelectorAll('.server-tab-badge')[0];
+    this.$badge = this.$el.querySelector(".server-tab-badge")!;
+  }
+
+  override async activate(): Promise<void> {
+    await super.activate();
+    (await this.webview).load();
+  }
+
+  override async deactivate(): Promise<void> {
+    await super.deactivate();
+    (await this.webview).hide();
+  }
+
+  override async destroy(): Promise<void> {
+    await super.destroy();
+    (await this.webview).$el.remove();
+  }
+
+  templateHtml(): Html {
+    return html`
+      <div class="tab" data-tab-id="${this.props.tabIndex}">
+        <div class="server-tooltip" style="display:none">
+          ${this.props.name}
+        </div>
+        <div class="server-tab-badge"></div>
+        <div class="server-tab">
+          <img class="server-icons" src="${this.props.icon}" />
+        </div>
+        <div class="server-tab-shortcut">${this.generateShortcutText()}</div>
+      </div>
+    `;
   }
 
   updateBadge(count: number): void {
-		if (count > 0) {
+    this.$badge.textContent = count > 999 ? "1K+" : count.toString();
-			const formattedCount = count > 999 ? '1K+' : count.toString();
+    this.$badge.classList.toggle("active", count > 0);
-			this.$badge.innerHTML = formattedCount;
-			this.$badge.classList.add('active');
-		} else {
-			this.$badge.classList.remove('active');
-		}
   }
 
   generateShortcutText(): string {
-		// Only provide shortcuts for server [0..10]
+    // Only provide shortcuts for server [0..9]
-		if (this.props.index >= 10) {
+    if (this.props.index >= 9) {
-			return '';
+      return "";
     }
 
     const shownIndex = this.props.index + 1;
 
-		let shortcutText = '';
-
-		if (SystemUtil.getOS() === 'Mac') {
-			shortcutText = `⌘ ${shownIndex}`;
-		} else {
-			shortcutText = `Ctrl+${shownIndex}`;
-		}
-
     // Array index == Shown index - 1
-		ipcRenderer.send('switch-server-tab', shownIndex - 1);
+    ipcRenderer.send("switch-server-tab", shownIndex - 1);
 
-		return shortcutText;
+    return process.platform === "darwin"
+      ? `⌘${shownIndex}`
+      : `Ctrl+${shownIndex}`;
   }
 }

app/renderer/js/components/tab.ts

@@ -1,8 +1,7 @@
-import WebView from './webview';
+import type {TabRole} from "../../../common/types";
-import BaseComponent from './base';
 
 export interface TabProps {
-	role: string;
+  role: TabRole;
   icon?: string;
   name: string;
   $root: Element;
@@ -11,44 +10,39 @@ export interface TabProps {
   tabIndex: number;
   onHover?: () => void;
   onHoverOut?: () => void;
-	webview: WebView;
   materialIcon?: string;
   onDestroy?: () => void;
 }
 
-export default class Tab extends BaseComponent {
+export default abstract class Tab {
   props: TabProps;
-	webview: WebView;
+  abstract $el: Element;
-	$el: Element;
-	constructor(props: TabProps) {
-		super();
 
+  constructor(props: TabProps) {
     this.props = props;
-		this.webview = this.props.webview;
   }
 
   registerListeners(): void {
-		this.$el.addEventListener('click', this.props.onClick);
+    this.$el.addEventListener("click", this.props.onClick);
-		this.$el.addEventListener('mouseover', this.props.onHover);
+
-		this.$el.addEventListener('mouseout', this.props.onHoverOut);
+    if (this.props.onHover !== undefined) {
+      this.$el.addEventListener("mouseover", this.props.onHover);
     }
 
-	showNetworkError(): void {
+    if (this.props.onHoverOut !== undefined) {
-		this.webview.forceLoad();
+      this.$el.addEventListener("mouseout", this.props.onHoverOut);
+    }
   }
 
-	activate(): void {
+  async activate(): Promise<void> {
-		this.$el.classList.add('active');
+    this.$el.classList.add("active");
-		this.webview.load();
   }
 
-	deactivate(): void {
+  async deactivate(): Promise<void> {
-		this.$el.classList.remove('active');
+    this.$el.classList.remove("active");
-		this.webview.hide();
   }
 
-	destroy(): void {
+  async destroy(): Promise<void> {
-		this.$el.parentNode.removeChild(this.$el);
+    this.$el.remove();
-		this.webview.$el.parentNode.removeChild(this.webview.$el);
   }
 }

app/renderer/js/components/webview.ts

@@ -1,168 +1,202 @@
-import { ipcRenderer, remote } from 'electron';
+import type {WebContents} from "electron/main";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
 
-import path from 'path';
+import * as remote from "@electron/remote";
-import fs from 'fs';
+import {app, dialog} from "@electron/remote";
-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;
+import * as ConfigUtil from "../../../common/config-util";
+import type {Html} from "../../../common/html";
+import {html} from "../../../common/html";
+import type {RendererMessage} from "../../../common/typed-ipc";
+import type {TabRole} from "../../../common/types";
+import {ipcRenderer} from "../typed-ipc-renderer";
+import * as SystemUtil from "../utils/system-util";
 
-const shouldSilentWebview = ConfigUtil.getConfigItem('silent');
+import {generateNodeFromHtml} from "./base";
+import {contextMenu} from "./context-menu";
+
+const shouldSilentWebview = ConfigUtil.getConfigItem("silent", false);
 
 interface WebViewProps {
   $root: Element;
+  rootWebContents: WebContents;
   index: number;
   tabIndex: number;
-	url: any;
+  url: string;
-	role: string;
+  role: TabRole;
-	name: string;
   isActive: () => boolean;
-	switchLoading: (loading: any, url: string) => void;
+  switchLoading: (loading: boolean, url: string) => void;
   onNetworkError: (index: number) => void;
-	nodeIntegration: boolean;
+  preload?: string;
-	preload: boolean;
+  onTitleChange: () => void;
-	onTitleChange: any;
   hasPermission?: (origin: string, permission: string) => boolean;
 }
 
-export default class WebView extends BaseComponent {
+export default class WebView {
+  static templateHtml(props: WebViewProps): Html {
+    return html`
+      <webview
+        data-tab-id="${props.tabIndex}"
+        src="${props.url}"
+        ${props.preload === undefined
+          ? html``
+          : html`preload="${props.preload}"`}
+        partition="persist:webviewsession"
+        allowpopups
+      >
+      </webview>
+    `;
+  }
+
+  static async create(props: WebViewProps): Promise<WebView> {
+    const $element = generateNodeFromHtml(
+      WebView.templateHtml(props),
+    ) as HTMLElement;
+    props.$root.append($element);
+
+    // Wait for did-navigate rather than did-attach to work around
+    // https://github.com/electron/electron/issues/31918
+    await new Promise<void>((resolve) => {
+      $element.addEventListener(
+        "did-navigate",
+        () => {
+          resolve();
+        },
+        true,
+      );
+    });
+
+    // Work around https://github.com/electron/electron/issues/26904
+    function getWebContentsIdFunction(
+      this: undefined,
+      selector: string,
+    ): number {
+      return document
+        .querySelector<Electron.WebviewTag>(selector)!
+        .getWebContentsId();
+    }
+
+    const selector = `webview[data-tab-id="${CSS.escape(
+      `${props.tabIndex}`,
+    )}"]`;
+    const webContentsId: unknown =
+      await props.rootWebContents.executeJavaScript(
+        `(${getWebContentsIdFunction.toString()})(${JSON.stringify(selector)})`,
+      );
+    if (typeof webContentsId !== "number") {
+      throw new TypeError("Failed to get WebContents ID");
+    }
+
+    return new WebView(props, $element, webContentsId);
+  }
+
   props: WebViewProps;
   zoomFactor: number;
   badgeCount: number;
   loading: boolean;
-	customCSS: string;
+  customCss: string | false | null;
   $webviewsContainer: DOMTokenList;
-	$el: Electron.WebviewTag;
+  $el: HTMLElement;
-	domReady?: Promise<void>;
+  webContentsId: number;
-
-	// This is required because in main.js we access WebView.method as
-	// webview[method].
-	[key: string]: any;
-
-	constructor(props: WebViewProps) {
-		super();
 
+  private constructor(
+    props: WebViewProps,
+    $element: HTMLElement,
+    webContentsId: number,
+  ) {
     this.props = props;
     this.zoomFactor = 1;
     this.loading = true;
     this.badgeCount = 0;
-		this.customCSS = ConfigUtil.getConfigItem('customCSS');
+    this.customCss = ConfigUtil.getConfigItem("customCSS", null);
-		this.$webviewsContainer = document.querySelector('#webviews-container').classList;
+    this.$webviewsContainer = document.querySelector(
-	}
+      "#webviews-container",
-
+    )!.classList;
-	template(): string {
+    this.$el = $element;
-		return `<webview
+    this.webContentsId = webContentsId;
-					class="disabled"
-					data-tab-id="${this.props.tabIndex}"
-					src="${this.props.url}"
-					${this.props.nodeIntegration ? 'nodeIntegration' : ''}
-					${this.props.preload ? 'preload="js/preload.js"' : ''}
-					partition="persist:webviewsession"
-					name="${this.props.name}"
-					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();
   }
 
-	registerListeners(): void {
+  getWebContents(): WebContents {
-		this.$el.addEventListener('new-window', event => {
+    return remote.webContents.fromId(this.webContentsId);
-			handleExternalLink.call(this, event);
-		});
-
-		if (shouldSilentWebview) {
-			this.$el.addEventListener('dom-ready', () => {
-				this.$el.setAudioMuted(true);
-			});
   }
 
-		this.$el.addEventListener('page-title-updated', event => {
+  registerListeners(): void {
-			const { title } = event;
+    const webContents = this.getWebContents();
+
+    if (shouldSilentWebview) {
+      webContents.setAudioMuted(true);
+    }
+
+    webContents.on("page-title-updated", (_event, title) => {
       this.badgeCount = this.getBadgeCount(title);
       this.props.onTitleChange();
     });
 
-		this.$el.addEventListener('did-navigate-in-page', event => {
+    this.$el.addEventListener("did-navigate-in-page", () => {
-			const isSettingPage = event.url.includes('renderer/preference.html');
-			if (isSettingPage) {
-				return;
-			}
       this.canGoBackButton();
     });
 
-		this.$el.addEventListener('did-navigate', () => {
+    this.$el.addEventListener("did-navigate", () => {
       this.canGoBackButton();
     });
 
-		this.$el.addEventListener('page-favicon-updated', event => {
+    webContents.on("page-favicon-updated", (_event, favicons) => {
-			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') {
+      if (
+        favicons[0].indexOf("favicon-pms") > 0 &&
+        process.platform === "darwin"
+      ) {
         // This api is only supported on macOS
-				app.dock.setBadge('●');
+        app.dock.setBadge("●");
-				// bounce the dock
+        // Bounce the dock
-				if (ConfigUtil.getConfigItem('dockBouncing')) {
+        if (ConfigUtil.getConfigItem("dockBouncing", true)) {
           app.dock.bounce();
         }
       }
     });
 
-		this.$el.addEventListener('dom-ready', () => {
+    webContents.addListener("context-menu", (event, menuParameters) => {
-			if (this.props.role === 'server') {
+      contextMenu(webContents, event, menuParameters);
-				this.$el.classList.add('onload');
+    });
-			}
+
+    this.$el.addEventListener("dom-ready", () => {
       this.loading = false;
       this.props.switchLoading(false, this.props.url);
       this.show();
-
-			// Refocus text boxes after reload
-			// Remove when upstream issue https://github.com/electron/electron/issues/14474 is fixed
-			this.$el.blur();
-			this.$el.focus();
     });
 
-		this.$el.addEventListener('did-fail-load', event => {
+    webContents.on("did-fail-load", (_event, _errorCode, errorDescription) => {
-			const { errorDescription } = event;
+      const hasConnectivityError =
-			const hasConnectivityErr = SystemUtil.connectivityERR.includes(errorDescription);
+        SystemUtil.connectivityError.includes(errorDescription);
-			if (hasConnectivityErr) {
+      if (hasConnectivityError) {
-				console.error('error', errorDescription);
+        console.error("error", errorDescription);
-				if (!this.props.url.includes('network.html')) {
+        if (!this.props.url.includes("network.html")) {
           this.props.onNetworkError(this.props.index);
         }
       }
     });
 
-		this.$el.addEventListener('did-start-loading', () => {
+    this.$el.addEventListener("did-start-loading", () => {
-			const isSettingPage = this.props.url.includes('renderer/preference.html');
-			if (!isSettingPage) {
       this.props.switchLoading(true, this.props.url);
-			}
     });
 
-		this.$el.addEventListener('did-stop-loading', () => {
+    this.$el.addEventListener("did-stop-loading", () => {
       this.props.switchLoading(false, this.props.url);
     });
   }
 
   getBadgeCount(title: string): number {
-		const messageCountInTitle = (/\((\d+)\)/).exec(title);
+    const messageCountInTitle = /^\((\d+)\)/.exec(title);
     return messageCountInTitle ? Number(messageCountInTitle[1]) : 0;
   }
 
   showNotificationSettings(): void {
-		ipcRenderer.sendTo(this.$el.getWebContentsId(), 'show-notification-settings');
+    this.send("show-notification-settings");
   }
 
   show(): void {
@@ -172,132 +206,111 @@ export default class WebView extends BaseComponent {
     }
 
     // To show or hide the loading indicator in the the active tab
-		if (this.loading) {
+    this.$webviewsContainer.toggle("loaded", !this.loading);
-			this.$webviewsContainer.remove('loaded');
-		} else {
-			this.$webviewsContainer.add('loaded');
-		}
 
-		this.$el.classList.remove('disabled');
+    this.$el.classList.add("active");
-		this.$el.classList.add('active');
-		setTimeout(() => {
-			if (this.props.role === 'server') {
-				this.$el.classList.remove('onload');
-			}
-		}, 1000);
     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.getWebContents().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');
+    const customCss = ConfigUtil.getConfigItem("customCSS", null);
-		if (this.customCSS) {
+    this.customCss = customCss;
-			if (!fs.existsSync(this.customCSS)) {
+    if (customCss) {
-				this.customCSS = null;
+      if (!fs.existsSync(customCss)) {
-				ConfigUtil.setConfigItem('customCSS', null);
+        this.customCss = null;
+        ConfigUtil.setConfigItem("customCSS", null);
 
-				const errorMessage = 'The custom css previously set is deleted!';
+        const errorMessage = "The custom css previously set is deleted!";
-				dialog.showErrorBox('custom css file deleted!', errorMessage);
+        dialog.showErrorBox("custom css file deleted!", errorMessage);
         return;
       }
 
-			this.$el.insertCSS(fs.readFileSync(path.resolve(__dirname, this.customCSS), 'utf8'));
+      (async () =>
+        this.getWebContents().insertCSS(
+          fs.readFileSync(path.resolve(__dirname, customCss), "utf8"),
+        ))();
     }
   }
 
   focus(): void {
-		// 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`.
-		if (webContents && this.$el !== document.activeElement) {
-			// HACK: Looks like blur needs to be called on the previously focused
-			// element to transfer focus correctly, in Electron v3.0.10
-			// See https://github.com/electron/electron/issues/15718
-			(document.activeElement as HTMLElement).blur();
     this.$el.focus();
-			webContents.focus();
+    // Work around https://github.com/electron/electron/issues/31918
-		}
+    this.$el.shadowRoot?.querySelector("iframe")?.focus();
   }
 
   hide(): void {
-		this.$el.classList.add('disabled');
+    this.$el.classList.remove("active");
-		this.$el.classList.remove('active');
   }
 
   load(): void {
-		if (this.$el) {
     this.show();
-		} else {
-			this.init();
-		}
   }
 
   zoomIn(): void {
     this.zoomFactor += 0.1;
-		this.$el.setZoomFactor(this.zoomFactor);
+    this.getWebContents().setZoomFactor(this.zoomFactor);
   }
 
   zoomOut(): void {
     this.zoomFactor -= 0.1;
-		this.$el.setZoomFactor(this.zoomFactor);
+    this.getWebContents().setZoomFactor(this.zoomFactor);
   }
 
   zoomActualSize(): void {
     this.zoomFactor = 1;
-		this.$el.setZoomFactor(this.zoomFactor);
+    this.getWebContents().setZoomFactor(this.zoomFactor);
   }
 
   logOut(): void {
-		ipcRenderer.sendTo(this.$el.getWebContentsId(), 'logout');
+    this.send("logout");
   }
 
-	showShortcut(): void {
+  showKeyboardShortcuts(): void {
-		ipcRenderer.sendTo(this.$el.getWebContentsId(), 'shortcut');
+    this.send("show-keyboard-shortcuts");
   }
 
   openDevTools(): void {
-		this.$el.openDevTools();
+    this.getWebContents().openDevTools();
   }
 
   back(): void {
-		if (this.$el.canGoBack()) {
+    if (this.getWebContents().canGoBack()) {
-			this.$el.goBack();
+      this.getWebContents().goBack();
       this.focus();
     }
   }
 
   canGoBackButton(): void {
-		const $backButton = document.querySelector('#actions-container #back-action');
+    const $backButton = document.querySelector(
-		if (this.$el.canGoBack()) {
+      "#actions-container #back-action",
-			$backButton.classList.remove('disable');
+    )!;
-		} else {
+    $backButton.classList.toggle("disable", !this.getWebContents().canGoBack());
-			$backButton.classList.add('disable');
-		}
   }
 
   forward(): void {
-		if (this.$el.canGoForward()) {
+    if (this.getWebContents().canGoForward()) {
-			this.$el.goForward();
+      this.getWebContents().goForward();
     }
   }
 
   reload(): void {
     this.hide();
     // Shows the loading indicator till the webview is reloaded
-		this.$webviewsContainer.remove('loaded');
+    this.$webviewsContainer.remove("loaded");
     this.loading = true;
     this.props.switchLoading(true, this.props.url);
-		this.$el.reload();
+    this.getWebContents().reload();
   }
 
-	forceLoad(): void {
+  send<Channel extends keyof RendererMessage>(
-		this.init();
+    channel: Channel,
-	}
+    ...args: Parameters<RendererMessage[Channel]>
-
+  ): void {
-	async send(channel: string, ...parameters: any[]): Promise<void> {
+    ipcRenderer.sendTo(this.webContentsId, channel, ...args);
-		await this.domReady;
-		this.$el.send(channel, ...parameters);
   }
 }

app/renderer/js/electron-bridge.ts

@@ -1,71 +1,109 @@
-import { ipcRenderer } from 'electron';
+import {EventEmitter} from "node:events";
 
-import { EventEmitter } from 'events';
+import type {ClipboardDecrypter} from "./clipboard-decrypter";
+import {ClipboardDecrypterImpl} from "./clipboard-decrypter";
+import type {NotificationData} from "./notification";
+import {newNotification} from "./notification";
+import {ipcRenderer} from "./typed-ipc-renderer";
 
-import { NotificationData, newNotification } from './notification';
+type ListenerType = (...args: any[]) => void;
 
-type ListenerType = ((...args: any[]) => void);
+export interface ElectronBridge {
-
+  send_event: (eventName: string | symbol, ...args: unknown[]) => boolean;
-class ElectronBridge extends EventEmitter {
+  on_event: (eventName: string, listener: ListenerType) => void;
-	send_notification_reply_message_supported: boolean;
+  new_notification: (
-	idle_on_system: boolean;
-	last_active_on_system: number;
-
-	constructor() {
-		super();
-		this.send_notification_reply_message_supported = false;
-		// Indicates if the user is idle or not
-		this.idle_on_system = false;
-
-		// Indicates the time at which user was last active
-		this.last_active_on_system = Date.now();
-	}
-
-	send_event = (eventName: string | symbol, ...args: any[]): void => {
-		this.emit(eventName, ...args);
-	};
-
-	on_event = (eventName: string, listener: ListenerType): void => {
-		this.on(eventName, listener);
-	};
-
-	new_notification = (
     title: string,
-		options: NotificationOptions | undefined,
+    options: NotificationOptions,
-		dispatch: (type: string, eventInit: EventInit) => boolean
+    dispatch: (type: string, eventInit: EventInit) => boolean,
-	): NotificationData =>
+  ) => NotificationData;
-		newNotification(title, options, dispatch);
+  get_idle_on_system: () => boolean;
-
+  get_last_active_on_system: () => number;
-	get_idle_on_system = (): boolean => this.idle_on_system;
+  get_send_notification_reply_message_supported: () => boolean;
-
+  set_send_notification_reply_message_supported: (value: boolean) => void;
-	get_last_active_on_system = (): number => this.last_active_on_system;
+  decrypt_clipboard: (version: number) => ClipboardDecrypter;
-
-	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;
-	};
 }
 
-const electron_bridge = new ElectronBridge();
+let notificationReplySupported = false;
+// Indicates if the user is idle or not
+let idle = false;
+// Indicates the time at which user was last active
+let lastActive = Date.now();
 
-electron_bridge.on('total_unread_count', (...args) => {
+export const bridgeEvents = new EventEmitter();
-	ipcRenderer.send('unread-count', ...args);
+
+/* eslint-disable @typescript-eslint/naming-convention */
+const electron_bridge: ElectronBridge = {
+  send_event: (eventName: string | symbol, ...args: unknown[]): boolean =>
+    bridgeEvents.emit(eventName, ...args),
+
+  on_event(eventName: string, listener: ListenerType): void {
+    bridgeEvents.on(eventName, listener);
+  },
+
+  new_notification: (
+    title: string,
+    options: NotificationOptions,
+    dispatch: (type: string, eventInit: EventInit) => boolean,
+  ): NotificationData => newNotification(title, options, dispatch),
+
+  get_idle_on_system: (): boolean => idle,
+
+  get_last_active_on_system: (): number => lastActive,
+
+  get_send_notification_reply_message_supported: (): boolean =>
+    notificationReplySupported,
+
+  set_send_notification_reply_message_supported(value: boolean): void {
+    notificationReplySupported = value;
+  },
+
+  decrypt_clipboard: (version: number): ClipboardDecrypter =>
+    new ClipboardDecrypterImpl(version),
+};
+/* eslint-enable @typescript-eslint/naming-convention */
+
+bridgeEvents.on("total_unread_count", (unreadCount: unknown) => {
+  if (typeof unreadCount !== "number") {
+    throw new TypeError("Expected string for unreadCount");
+  }
+
+  ipcRenderer.send("unread-count", unreadCount);
 });
 
-electron_bridge.on('realm_name', realmName => {
+bridgeEvents.on("realm_name", (realmName: unknown) => {
-	const serverURL = location.origin;
+  if (typeof realmName !== "string") {
-	ipcRenderer.send('realm-name-changed', serverURL, realmName);
+    throw new TypeError("Expected string for realmName");
+  }
+
+  const serverUrl = location.origin;
+  ipcRenderer.send("realm-name-changed", serverUrl, realmName);
 });
 
-electron_bridge.on('realm_icon_url', iconURL => {
+bridgeEvents.on("realm_icon_url", (iconUrl: unknown) => {
-	const serverURL = location.origin;
+  if (typeof iconUrl !== "string") {
-	iconURL = iconURL.includes('http') ? iconURL : `${serverURL}${iconURL}`;
+    throw new TypeError("Expected string for iconUrl");
-	ipcRenderer.send('realm-icon-changed', serverURL, iconURL);
+  }
+
+  const serverUrl = location.origin;
+  ipcRenderer.send(
+    "realm-icon-changed",
+    serverUrl,
+    iconUrl.includes("http") ? iconUrl : `${serverUrl}${iconUrl}`,
+  );
 });
 
-// this follows node's idiomatic implementation of event
+// Set user as active and update the time of last activity
+ipcRenderer.on("set-active", () => {
+  idle = false;
+  lastActive = Date.now();
+});
+
+// Set user as idle and time of last activity is left unchanged
+ipcRenderer.on("set-idle", () => {
+  idle = true;
+});
+
+// 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

app/renderer/js/feedback.ts

@@ -1,80 +0,0 @@
-import { remote } from 'electron';
-import SendFeedback from '@electron-elements/send-feedback';
-
-import path from 'path';
-import fs from 'fs';
-
-const { app } = remote;
-
-interface SendFeedback extends HTMLElement {
-	[key: string]: any;
-}
-
-type SendFeedbackType = SendFeedback;
-
-// make the button color match zulip app's theme
-SendFeedback.customStyles = `
-button:hover, button:focus {
-  border-color: #4EBFAC;
-  color: #4EBFAC;
-}
-
-button:active {
-  background-color: #f1f1f1;
-  color: #4EBFAC;
-}
-
-button {
-  background-color: #4EBFAC;
-  border-color: #4EBFAC;
-}
-`;
-
-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...\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 = '';
-
-sendFeedback.useReporter('emailReporter', {
-	email: 'akash@zulipchat.com'
-});
-
-feedbackHolder.addEventListener('click', (event: Event) => {
-	// only remove the class if the grey out faded
-	// part is clicked and not the feedback element itself
-	if (event.target === event.currentTarget) {
-		feedbackHolder.classList.remove('show');
-	}
-});
-
-sendFeedback.addEventListener('feedback-submitted', () => {
-	setTimeout(() => {
-		feedbackHolder.classList.remove('show');
-	}, 1000);
-});
-
-const dataDir = app.getPath('userData');
-const logsDir = path.join(dataDir, '/Logs');
-sendFeedback.logs.push(...fs.readdirSync(logsDir).map(file => path.join(logsDir, file)));

app/renderer/js/injected.ts

@@ -1,64 +1,51 @@
-'use strict';
+"use strict";
+
+type ElectronBridge = import("./electron-bridge").ElectronBridge;
+
+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: any;
+    electron_bridge: CompatElectronBridge;
-		narrow: any;
+    raw_electron_bridge: ElectronBridge;
-		page_params: any;
-		raw_electron_bridge: any;
   };
 
-	const electron_bridge = {
+  /* eslint-disable @typescript-eslint/naming-convention */
+  const electron_bridge: CompatElectronBridge = {
     ...zulipWindow.raw_electron_bridge,
 
-		get idle_on_system() {
+    get idle_on_system(): boolean {
       return this.get_idle_on_system();
     },
 
-		get last_active_on_system() {
+    get last_active_on_system(): number {
       return this.get_last_active_on_system();
     },
 
-		get send_notification_reply_message_supported() {
+    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);
-		}
+    },
   };
+  /* eslint-enable @typescript-eslint/naming-convention */
 
   zulipWindow.electron_bridge = electron_bridge;
 
-	(async () => {
+  function attributeListener<T extends EventTarget>(
-		if (document.readyState === 'loading') {
+    type: string,
-			await new Promise(resolve => {
+  ): PropertyDescriptor {
-				document.addEventListener('DOMContentLoaded', () => {
+    const handlers = new WeakMap<T, (event: Event) => unknown>();
-					resolve();
-				});
-			});
-		}
 
-		const { page_params } = zulipWindow;
+    function listener(this: T, event: Event): void {
-		if (page_params) {
+      if (handlers.get(this)!.call(this, event) === false) {
-			electron_bridge.send_event('zulip-loaded', {
+        event.preventDefault();
-				serverLanguage: page_params.default_language
-			});
-		}
-	})();
-
-	electron_bridge.on_event('narrow-by-topic', (id: string) => {
-		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();
       }
     }
 
@@ -66,57 +53,61 @@
       configurable: true,
       enumerable: true,
       get(this: T) {
-				return (this as any)[symbol];
+        return handlers.get(this);
       },
       set(this: T, value: unknown) {
-				if (typeof value === 'function') {
+        if (typeof value === "function") {
-					if (!(symbol in this)) {
+          if (!handlers.has(this)) {
             this.addEventListener(type, listener);
           }
-					(this as any)[symbol] = value;
+
-				} else if (symbol in this) {
+          handlers.set(this, value as (event: Event) => unknown);
+        } else if (handlers.has(this)) {
           this.removeEventListener(type, listener);
-					delete (this as any)[symbol];
+          handlers.delete(this);
-				}
         }
+      },
     };
   }
 
+  // eslint-disable-next-line @typescript-eslint/naming-convention
   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> {
+    static async requestPermission(
+      callback?: NotificationPermissionCallback,
+    ): Promise<NotificationPermission> {
       if (callback) {
         callback(await Promise.resolve(NativeNotification.permission));
       }
+
       return NativeNotification.permission;
     }
+
+    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)),
+        ),
+      );
+    }
   }
 
   Object.defineProperties(InjectedNotification.prototype, {
-		onclick: attributeListener('click'),
+    onclick: attributeListener("click"),
-		onclose: attributeListener('close'),
+    onclose: attributeListener("close"),
-		onerror: attributeListener('error'),
+    onerror: attributeListener("error"),
-		onshow: attributeListener('show')
+    onshow: attributeListener("show"),
   });
 
-	window.Notification = InjectedNotification as any;
+  window.Notification = InjectedNotification as unknown as typeof Notification;
 })();

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

@@ -1,111 +0,0 @@
-import { ipcRenderer } from 'electron';
-import {
-	appId, customReply, focusCurrentServer, parseReply
-} from './helpers';
-
-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;
-
-interface NotificationHandlerArgs {
-	response: string;
-}
-
-class DarwinNotification {
-	tag: string;
-
-	constructor(title: string, options: NotificationOptions) {
-		const silent: boolean = ConfigUtil.getConfigItem('silent') || false;
-		const { icon } = options;
-		const profilePic = new URL(icon, location.href).href;
-
-		this.tag = options.tag;
-		const notification = new MacNotifier(title, Object.assign(options, {
-			bundleId: appId,
-			canReply: true,
-			silent,
-			icon: profilePic
-		}));
-
-		notification.addEventListener('click', () => {
-			// focus to the server who sent the
-			// notification if not focused already
-			if (clickHandler) {
-				clickHandler();
-			}
-
-			focusCurrentServer();
-			ipcRenderer.send('focus-app');
-		});
-
-		notification.addEventListener('reply', this.notificationHandler);
-	}
-
-	static requestPermission(): void {
-		return; // eslint-disable-line no-useless-return
-	}
-
-	// Override default Notification permission
-	static get permission(): NotificationPermission {
-		return ConfigUtil.getConfigItem('showNotification') ? 'granted' : 'denied';
-	}
-
-	get onreply(): ReplyHandler {
-		return replyHandler;
-	}
-
-	set onreply(handler: ReplyHandler) {
-		replyHandler = handler;
-	}
-
-	get onclick(): ClickHandler {
-		return clickHandler;
-	}
-
-	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 {
-		if (event === 'click') {
-			clickHandler = handler as ClickHandler;
-		}
-
-		if (event === 'reply') {
-			replyHandler = handler as ReplyHandler;
-		}
-	}
-
-	async notificationHandler({ response }: NotificationHandlerArgs): Promise<void> {
-		response = await parseReply(response);
-		focusCurrentServer();
-		if (electron_bridge.send_notification_reply_message_supported) {
-			electron_bridge.send_event('send_notification_reply_message', this.tag, response);
-			return;
-		}
-
-		electron_bridge.emit('narrow-by-topic', this.tag);
-		if (replyHandler) {
-			replyHandler(response);
-			return;
-		}
-
-		customReply(response);
-	}
-
-	// method specific to notification api
-	// used by zulip
-	close(): void {
-		return; // eslint-disable-line no-useless-return
-	}
-}
-
-module.exports = DarwinNotification;

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

@@ -1,28 +0,0 @@
-import { ipcRenderer } from 'electron';
-import { focusCurrentServer } from './helpers';
-
-import * as ConfigUtil from '../utils/config-util';
-
-const NativeNotification = window.Notification;
-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
-			// notification if not focused already
-			focusCurrentServer();
-			ipcRenderer.send('focus-app');
-		});
-	}
-
-	static async requestPermission(): Promise<NotificationPermission> {
-		return this.permission;
-	}
-
-	// Override default Notification permission
-	static get permission(): NotificationPermission {
-		return ConfigUtil.getConfigItem('showNotification') ? 'granted' : 'denied';
-	}
-}

app/renderer/js/notification/helpers.ts

@@ -1,136 +0,0 @@
-import { remote } from 'electron';
-
-import Logger from '../utils/logger-util';
-
-const logger = new Logger({
-	file: 'errors.log',
-	timestamp: true
-});
-
-// Do not change this
-export const appId = 'org.zulip.zulip-electron';
-
-export type BotListItem = [string, string];
-const botsList: BotListItem[] = [];
-let botsListLoaded = false;
-
-// this function load list of bots from the server
-// in case botsList isn't already completely loaded when required in parseRely
-export async function loadBots(): Promise<void> {
-	botsList.length = 0;
-	const response = await fetch('/json/users');
-	if (response.ok) {
-		const { members } = await response.json();
-		members.forEach((membersRow: any) => {
-			if (membersRow.is_bot) {
-				const bot = `@${membersRow.full_name}`;
-				const mention = `@**${bot.replace(/^@/, '')}**`;
-				botsList.push([bot, mention]);
-			}
-		});
-		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 {
-	let status = true;
-	elements.forEach(element => {
-		if (element === null || element === undefined) {
-			status = false;
-		}
-	});
-	return status;
-}
-
-export function customReply(reply: string): void {
-	// 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
-	const elementsExists = checkElements(textarea, messagebox, sendButton);
-	if (!elementsExists) {
-		return;
-	}
-
-	textarea.value = reply;
-	messagebox.click();
-	sendButton.click();
-}
-
-const currentWindow = remote.getCurrentWindow();
-const webContents = remote.getCurrentWebContents();
-const webContentsId = webContents.id;
-
-// this function will focus the server that sent
-// the notification. Main function implemented in main.js
-export function focusCurrentServer(): void {
-	currentWindow.webContents.send('focus-webview-with-id', webContentsId);
-}
-// 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 async function parseReply(reply: string): Promise<string> {
-	const usersDiv = document.querySelectorAll('#user_presences li');
-	const streamHolder = document.querySelectorAll('#stream_filters li');
-
-	type UsersItem = BotListItem;
-	type StreamsItem = BotListItem;
-	const users: UsersItem[] = [];
-	const streams: StreamsItem[] = [];
-
-	usersDiv.forEach(userRow => {
-		const anchor = userRow.querySelector('span a');
-		if (anchor !== null) {
-			const user = `@${anchor.textContent.trim()}`;
-			const mention = `@**${user.replace(/^@/, '')}**`;
-			users.push([user, mention]);
-		}
-	});
-
-	streamHolder.forEach(stream => {
-		const streamAnchor = stream.querySelector('div a');
-		if (streamAnchor !== null) {
-			const streamName = `#${streamAnchor.textContent.trim()}`;
-			const streamMention = `#**${streamName.replace(/^#/, '')}**`;
-			streams.push([streamName, streamMention]);
-		}
-	});
-
-	users.forEach(([user, mention]) => {
-		if (reply.includes(user)) {
-			const regex = new RegExp(user, 'g');
-			reply = reply.replace(regex, mention);
-		}
-	});
-
-	streams.forEach(([stream, streamMention]) => {
-		const regex = new RegExp(stream, 'g');
-		reply = reply.replace(regex, streamMention);
-	});
-
-	// 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
-	// @botname with @**botname**
-	botsList.forEach(([bot, mention]) => {
-		if (reply.includes(bot)) {
-			const regex = new RegExp(bot, 'g');
-			reply = reply.replace(regex, mention);
-		}
-	});
-
-	reply = reply.replace(/\\n/, '\n');
-	return reply;
-}

app/renderer/js/notification/index.ts

@@ -1,72 +1,41 @@
-import { remote } from 'electron';
+import {ipcRenderer} from "../typed-ipc-renderer";
-import electron_bridge from '../electron-bridge';
-import { appId, loadBots } from './helpers';
-
-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);
-
-let Notification = DefaultNotification;
-
-if (process.platform === 'darwin') {
-	Notification = require('./darwin-notifications');
-}
 
 export interface NotificationData {
-	close(): void;
+  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,
+  options: NotificationOptions,
-	dispatch: (type: string, eventInit: EventInit) => boolean
+  dispatch: (type: string, eventInit: EventInit) => boolean,
 ): NotificationData {
-	const notification = new Notification(title, options);
+  const notification = new Notification(title, {...options, silent: true});
-	for (const type of ['click', 'close', 'error', 'show']) {
+  for (const type of ["click", "close", "error", "show"]) {
     notification.addEventListener(type, (ev: Event) => {
+      if (type === "click") ipcRenderer.send("focus-this-webview");
       if (!dispatch(type, ev)) {
         ev.preventDefault();
       }
     });
   }
+
   return {
-		close: () => notification.close(),
+    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', () => {
-	loadBots();
-});

app/renderer/js/pages/about.ts

@@ -0,0 +1,44 @@
+import {app} from "@electron/remote";
+
+import {html} from "../../../common/html";
+
+export class AboutView {
+  readonly $view: HTMLElement;
+
+  constructor() {
+    this.$view = document.createElement("div");
+    const $shadow = this.$view.attachShadow({mode: "open"});
+    $shadow.innerHTML = html`
+      <link rel="stylesheet" href="css/about.css" />
+      <!-- Initially hidden to prevent FOUC -->
+      <div class="about" hidden>
+        <img class="logo" src="../resources/zulip.png" />
+        <p class="detail" id="version">v${app.getVersion()}</p>
+        <div class="maintenance-info">
+          <p class="detail maintainer">
+            Maintained by
+            <a
+              href="https://zulip.com"
+              target="_blank"
+              rel="noopener noreferrer"
+              >Zulip</a
+            >
+          </p>
+          <p class="detail license">
+            Available under the
+            <a
+              href="https://github.com/zulip/zulip-desktop/blob/main/LICENSE"
+              target="_blank"
+              rel="noopener noreferrer"
+              >Apache 2.0 License</a
+            >
+          </p>
+        </div>
+      </div>
+    `.html;
+  }
+
+  destroy() {
+    // Do nothing.
+  }
+}

app/renderer/js/pages/network.ts

@@ -1,10 +1,13 @@
-import { ipcRenderer } from 'electron';
+import {ipcRenderer} from "../typed-ipc-renderer";
 
-export function init($reconnectButton: Element, $settingsButton: Element): void {
+export function init(
-	$reconnectButton.addEventListener('click', () => {
+  $reconnectButton: Element,
-		ipcRenderer.send('forward-message', 'reload-viewer');
+  $settingsButton: Element,
+): void {
+  $reconnectButton.addEventListener("click", () => {
+    ipcRenderer.send("forward-message", "reload-viewer");
   });
-	$settingsButton.addEventListener('click', () => {
+  $settingsButton.addEventListener("click", () => {
-		ipcRenderer.send('forward-message', 'open-settings');
+    ipcRenderer.send("forward-message", "open-settings");
   });
 }

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

@@ -1,98 +0,0 @@
-'use-strict';
-
-import { remote, OpenDialogOptions } from 'electron';
-
-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';
-
-interface AddCertificateProps {
-	$root: Element;
-}
-
-const { dialog } = remote;
-
-export default class AddCertificate extends BaseComponent {
-	props: AddCertificateProps;
-	_certFile: string;
-	$addCertificate: Element | null;
-	addCertificateButton: Element | null;
-	serverUrl: HTMLInputElement | null;
-	constructor(props: AddCertificateProps) {
-		super();
-		this.props = props;
-		this._certFile = '';
-	}
-
-	template(): string {
-		return `
-			<div class="settings-card certificates-card">
-				<div class="certificate-input">
-					<div>${t.__('Organization URL')}</div>
-					<input class="setting-input-value" autofocus placeholder="your-organization.zulipchat.com or zulip.your-organization.com"/>
-				</div>
-				<div class="certificate-input">
-					<div>${t.__('Certificate file')}</div>
-					<button class="green" id="add-certificate-button">${t.__('Upload')}</button>
-				</div>
-			</div>
-		`;
-	}
-
-	init(): void {
-		this.$addCertificate = this.generateNodeFromTemplate(this.template());
-		this.props.$root.append(this.$addCertificate);
-		this.addCertificateButton = this.$addCertificate.querySelector('#add-certificate-button');
-		this.serverUrl = this.$addCertificate.querySelectorAll('input.setting-input-value')[0] as HTMLInputElement;
-		this.initListeners();
-	}
-
-	validateAndAdd(): void {
-		const certificate = this._certFile;
-		const serverUrl = this.serverUrl.value;
-		if (certificate !== '' && serverUrl !== '') {
-			const server = encodeURIComponent(DomainUtil.formatUrl(serverUrl));
-			const fileName = path.basename(certificate);
-			const copy = CertificateUtil.copyCertificate(server, certificate, fileName);
-			if (!copy) {
-				return;
-			}
-			CertificateUtil.setCertificate(server, fileName);
-			dialog.showMessageBox({
-				title: 'Success',
-				message: 'Certificate saved!'
-			});
-			this.serverUrl.value = '';
-		} else {
-			dialog.showErrorBox('Error', `Please, ${serverUrl === '' ?
-				'Enter an Organization URL' : 'Choose certificate file'}`);
-		}
-	}
-
-	async addHandler(): Promise<void> {
-		const showDialogOptions: OpenDialogOptions = {
-			title: 'Select file',
-			properties: ['openFile'],
-			filters: [{ name: 'crt, pem', extensions: ['crt', 'pem'] }]
-		};
-		const { filePaths, canceled } = await dialog.showOpenDialog(showDialogOptions);
-		if (!canceled) {
-			this._certFile = filePaths[0] || '';
-			this.validateAndAdd();
-		}
-	}
-
-	initListeners(): void {
-		this.addCertificateButton.addEventListener('click', () => {
-			this.addHandler();
-		});
-
-		this.serverUrl.addEventListener('keypress', event => {
-			if (event.key === 'Enter') {
-				this.addHandler();
-			}
-		});
-	}
-}

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

@@ -1,43 +0,0 @@
-import electron, { app } from 'electron';
-
-import * as ConfigUtil from '../../utils/config-util';
-
-function showBadgeCount(messageCount: number, mainWindow: electron.BrowserWindow): void {
-	if (process.platform === 'win32') {
-		updateOverlayIcon(messageCount, mainWindow);
-	} else {
-		app.badgeCount = messageCount;
-	}
-}
-
-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,7 +1,7 @@
-import { ipcRenderer } from 'electron';
+import type {Html} from "../../../../common/html";
-import escape from 'escape-html';
+import {html} from "../../../../common/html";
-
+import {generateNodeFromHtml} from "../../components/base";
-import BaseComponent from '../../components/base';
+import {ipcRenderer} from "../../typed-ipc-renderer";
 
 interface BaseSectionProps {
   $element: HTMLElement;
@@ -10,56 +10,75 @@ interface BaseSectionProps {
   clickHandler: () => void;
 }
 
-export default class BaseSection extends BaseComponent {
+export function generateSettingOption(props: BaseSectionProps): void {
-	generateSettingOption(props: BaseSectionProps): void {
   const {$element, disabled, value, clickHandler} = props;
 
-		$element.innerHTML = '';
+  $element.textContent = "";
 
-		const $optionControl = this.generateNodeFromTemplate(this.generateOptionTemplate(value, disabled));
+  const $optionControl = generateNodeFromHtml(
+    generateOptionHtml(value, disabled),
+  );
   $element.append($optionControl);
 
   if (!disabled) {
-			$optionControl.addEventListener('click', clickHandler);
+    $optionControl.addEventListener("click", clickHandler);
-		}
-	}
-
-	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">
-					<div class="switch">
-					  <input class="toggle toggle-round" type="checkbox" checked disabled>
-					  ${label}
-					</div>
-				</div>
-			`;
-		} else {
-			return `
-				<div class="action">
-					<div class="switch">
-					  <input class="toggle toggle-round" type="checkbox">
-					  ${label}
-					</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 function generateOptionHtml(
+  settingOption: boolean,
+  disabled?: boolean,
+): Html {
+  const labelHtml = disabled
+    ? // eslint-disable-next-line unicorn/template-indent
+      html`<label
+        class="disallowed"
+        title="Setting locked by system administrator."
+      ></label>`
+    : html`<label></label>`;
+  if (settingOption) {
+    return html`
+      <div class="action">
+        <div class="switch">
+          <input class="toggle toggle-round" type="checkbox" checked disabled />
+          ${labelHtml}
+        </div>
+      </div>
+    `;
+  }
+
+  return html`
+    <div class="action">
+      <div class="switch">
+        <input class="toggle toggle-round" type="checkbox" />
+        ${labelHtml}
+      </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
+  */
+export function generateSelectHtml(
+  options: Record<string, string>,
+  className?: string,
+  idName?: string,
+): Html {
+  const optionsHtml = html``.join(
+    Object.keys(options).map(
+      (key) => html`
+        <option name="${key}" value="${key}">${options[key]}</option>
+      `,
+    ),
+  );
+  return html`
+    <select class="${className}" id="${idName}">
+      ${optionsHtml}
+    </select>
+  `;
+}
+
+export function reloadApp(): void {
+  ipcRenderer.send("forward-message", "reload-viewer");
+}

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

@@ -1,89 +1,65 @@
-import { ipcRenderer } from 'electron';
+import {html} from "../../../../common/html";
+import * as t from "../../../../common/translation-util";
+import {ipcRenderer} from "../../typed-ipc-renderer";
+import * as DomainUtil from "../../utils/domain-util";
 
-import BaseSection from './base-section';
+import {reloadApp} from "./base-section";
-import * as DomainUtil from '../../utils/domain-util';
+import {initFindAccounts} from "./find-accounts";
-import ServerInfoForm from './server-info-form';
+import {initServerInfoForm} from "./server-info-form";
-import AddCertificate from './add-certificate';
-import FindAccounts from './find-accounts';
-import * as t from '../../utils/translation-util';
 
 interface ConnectedOrgSectionProps {
   $root: Element;
 }
 
-export default class ConnectedOrgSection extends BaseSection {
+export function initConnectedOrgSection({
-	props: ConnectedOrgSectionProps;
+  $root,
-	$serverInfoContainer: Element | null;
+}: ConnectedOrgSectionProps): void {
-	$existingServers: Element | null;
+  $root.textContent = "";
-	$newOrgButton: HTMLButtonElement | null;
-	$addCertificateContainer: Element | null;
-	$findAccountsContainer: Element | null;
-	constructor(props: ConnectedOrgSectionProps) {
-		super();
-		this.props = props;
-	}
-
-	template(): string {
-		return `
-			<div class="settings-pane" id="server-settings-pane">
-				<div class="page-title">${t.__('Connected organizations')}</div>
-				<div class="title" id="existing-servers">${t.__('All the connected orgnizations will appear here.')}</div>
-				<div id="server-info-container"></div>
-				<div id="new-org-button"><button class="green sea w-250">${t.__('Connect to another organization')}</button></div>
-				<div class="page-title">${t.__('Add Custom Certificates')}</div>
-				<div id="add-certificate-container"></div>
-				<div class="page-title">${t.__('Find accounts by email')}</div>
-				<div id="find-accounts-container"></div>
-			</div>
-		`;
-	}
-
-	init(): void {
-		this.initServers();
-	}
-
-	initServers(): void {
-		this.props.$root.innerHTML = '';
 
   const servers = DomainUtil.getDomains();
-		this.props.$root.innerHTML = this.template();
+  $root.innerHTML = html`
+    <div class="settings-pane" id="server-settings-pane">
+      <div class="page-title">${t.__("Connected organizations")}</div>
+      <div class="title" id="existing-servers">
+        ${t.__("All the connected orgnizations will appear here.")}
+      </div>
+      <div id="server-info-container"></div>
+      <div id="new-org-button">
+        <button class="green sea w-250">
+          ${t.__("Connect to another organization")}
+        </button>
+      </div>
+      <div class="page-title">${t.__("Find accounts by email")}</div>
+      <div id="find-accounts-container"></div>
+    </div>
+  `.html;
 
-		this.$serverInfoContainer = document.querySelector('#server-info-container');
+  const $serverInfoContainer = $root.querySelector("#server-info-container")!;
-		this.$existingServers = document.querySelector('#existing-servers');
+  const $existingServers = $root.querySelector("#existing-servers")!;
-		this.$newOrgButton = document.querySelector('#new-org-button');
+  const $newOrgButton: HTMLButtonElement =
-		this.$addCertificateContainer = document.querySelector('#add-certificate-container');
+    $root.querySelector("#new-org-button")!;
-		this.$findAccountsContainer = document.querySelector('#find-accounts-container');
+  const $findAccountsContainer = $root.querySelector(
+    "#find-accounts-container",
+  )!;
 
-		const noServerText = t.__('All the connected orgnizations will appear here');
+  const noServerText = t.__("All the connected orgnizations will appear here");
   // Show noServerText if no servers are there otherwise hide it
-		this.$existingServers.innerHTML = servers.length === 0 ? noServerText : '';
+  $existingServers.textContent = servers.length === 0 ? noServerText : "";
 
   for (const [i, server] of servers.entries()) {
-			new ServerInfoForm({
+    initServerInfoForm({
-				$root: this.$serverInfoContainer,
+      $root: $serverInfoContainer,
       server,
       index: i,
-				onChange: this.reloadApp
+      onChange: reloadApp,
-			}).init();
+    });
   }
 
-		this.$newOrgButton.addEventListener('click', () => {
+  $newOrgButton.addEventListener("click", () => {
-			ipcRenderer.send('forward-message', 'open-org-tab');
+    ipcRenderer.send("forward-message", "open-org-tab");
   });
 
-		this.initAddCertificate();
+  initFindAccounts({
-		this.initFindAccounts();
+    $root: $findAccountsContainer,
-	}
+  });
-
-	initAddCertificate(): void {
-		new AddCertificate({
-			$root: this.$addCertificateContainer
-		}).init();
-	}
-
-	initFindAccounts(): void {
-		new FindAccounts({
-			$root: this.$findAccountsContainer
-		}).init();
-	}
 }

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

@@ -1,78 +1,66 @@
-'use-strict';
+import {html} from "../../../../common/html";
-
+import * as LinkUtil from "../../../../common/link-util";
-import BaseComponent from '../../components/base';
+import * as t from "../../../../common/translation-util";
-import * as LinkUtil from '../../utils/link-util';
+import {generateNodeFromHtml} from "../../components/base";
-import * as t from '../../utils/translation-util';
 
 interface FindAccountsProps {
   $root: Element;
 }
 
-export default class FindAccounts extends BaseComponent {
+async function findAccounts(url: string): Promise<void> {
-	props: FindAccountsProps;
-	$findAccounts: Element | null;
-	$findAccountsButton: Element | null;
-	$serverUrlField: HTMLInputElement | null;
-	constructor(props: FindAccountsProps) {
-		super();
-		this.props = props;
-	}
-
-	template(): string {
-		return `
-			<div class="settings-card certificate-card">
-				<div class="certificate-input">
-					<div>${t.__('Organization URL')}</div>
-					<input class="setting-input-value" value="zulipchat.com"/>
-				</div>
-				<div class="certificate-input">
-					<button class="green w-150" id="find-accounts-button">${t.__('Find accounts')}</button>
-				</div>
-			</div>
-		`;
-	}
-
-	init(): void {
-		this.$findAccounts = this.generateNodeFromTemplate(this.template());
-		this.props.$root.append(this.$findAccounts);
-		this.$findAccountsButton = this.$findAccounts.querySelector('#find-accounts-button');
-		this.$serverUrlField = this.$findAccounts.querySelectorAll('input.setting-input-value')[0] as HTMLInputElement;
-		this.initListeners();
-	}
-
-	findAccounts(url: string): void {
   if (!url) {
     return;
   }
-		if (!url.startsWith('http')) {
+
-			url = 'https://' + url;
+  if (!url.startsWith("http")) {
-		}
+    url = "https://" + url;
-		LinkUtil.openBrowser(new URL('/accounts/find', url));
   }
 
-	initListeners(): void {
+  await LinkUtil.openBrowser(new URL("/accounts/find", url));
-		this.$findAccountsButton.addEventListener('click', () => {
+}
-			this.findAccounts(this.$serverUrlField.value);
+
-		});
+export function initFindAccounts(props: FindAccountsProps): void {
-
+  const $findAccounts = generateNodeFromHtml(html`
-		this.$serverUrlField.addEventListener('click', () => {
+    <div class="settings-card certificate-card">
-			if (this.$serverUrlField.value === 'zulipchat.com') {
+      <div class="certificate-input">
-				this.$serverUrlField.setSelectionRange(0, 0);
+        <div>${t.__("Organization URL")}</div>
-			}
+        <input class="setting-input-value" value="zulipchat.com" />
-		});
+      </div>
-
+      <div class="certificate-input">
-		this.$serverUrlField.addEventListener('keypress', event => {
+        <button class="green w-150" id="find-accounts-button">
-			if (event.key === 'Enter') {
+          ${t.__("Find accounts")}
-				this.findAccounts(this.$serverUrlField.value);
+        </button>
-			}
+      </div>
-		});
+    </div>
-
+  `);
-		this.$serverUrlField.addEventListener('input', () => {
+  props.$root.append($findAccounts);
-			if (this.$serverUrlField.value) {
+  const $findAccountsButton = $findAccounts.querySelector(
-				this.$serverUrlField.classList.remove('invalid-input-value');
+    "#find-accounts-button",
-			} else {
+  )!;
-				this.$serverUrlField.classList.add('invalid-input-value');
+  const $serverUrlField: HTMLInputElement = $findAccounts.querySelector(
-			}
+    "input.setting-input-value",
-		});
+  )!;
-	}
+
+  $findAccountsButton.addEventListener("click", async () => {
+    await findAccounts($serverUrlField.value);
+  });
+
+  $serverUrlField.addEventListener("click", () => {
+    if ($serverUrlField.value === "zulipchat.com") {
+      $serverUrlField.setSelectionRange(0, 0);
+    }
+  });
+
+  $serverUrlField.addEventListener("keypress", async (event) => {
+    if (event.key === "Enter") {
+      await findAccounts($serverUrlField.value);
+    }
+  });
+
+  $serverUrlField.addEventListener("input", () => {
+    $serverUrlField.classList.toggle(
+      "invalid-input-value",
+      $serverUrlField.value === "",
+    );
+  });
 }

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

@@ -1,495 +1,691 @@
-import { ipcRenderer, remote, OpenDialogOptions } from 'electron';
+import type {OpenDialogOptions} from "electron/renderer";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
 
-import path from 'path';
+import * as remote from "@electron/remote";
-import fs from 'fs-extra';
+import {app, dialog, session} from "@electron/remote";
+import Tagify from "@yaireo/tagify";
+import ISO6391 from "iso-639-1";
+import * as z from "zod";
+
+import * as ConfigUtil from "../../../../common/config-util";
+import * as EnterpriseUtil from "../../../../common/enterprise-util";
+import {html} from "../../../../common/html";
+import * as t from "../../../../common/translation-util";
+import supportedLocales from "../../../../translations/supported-locales.json";
+import {ipcRenderer} from "../../typed-ipc-renderer";
+
+import {generateSelectHtml, generateSettingOption} from "./base-section";
 
-const { app, dialog } = remote;
 const currentBrowserWindow = remote.getCurrentWindow();
 
-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';
-
 interface GeneralSectionProps {
   $root: Element;
 }
 
-export default class GeneralSection extends BaseSection {
+export function initGeneralSection({$root}: GeneralSectionProps): void {
-	props: GeneralSectionProps;
+  $root.innerHTML = html`
-	constructor(props: GeneralSectionProps) {
-		super();
-		this.props = props;
-	}
-
-	template(): string {
-		return `
     <div class="settings-pane">
-                <div class="title">${t.__('Appearance')}</div>
+      <div class="title">${t.__("Appearance")}</div>
       <div id="appearance-option-settings" class="settings-card">
         <div class="setting-row" id="tray-option">
-						<div class="setting-description">${t.__('Show app icon in system tray')}</div>
+          <div class="setting-description">
+            ${t.__("Show app icon in system tray")}
+          </div>
           <div class="setting-control"></div>
         </div>
-					<div class="setting-row" id="menubar-option" style= "display:${process.platform === 'darwin' ? 'none' : ''}">
+        <div
-						<div class="setting-description">${t.__('Auto hide menu bar (Press Alt key to display)')}</div>
+          class="setting-row"
+          id="menubar-option"
+          style="display:${process.platform === "darwin" ? "none" : ""}"
+        >
+          <div class="setting-description">
+            ${t.__("Auto hide menu bar (Press Alt key to display)")}
+          </div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="sidebar-option">
-						<div class="setting-description">${t.__('Show sidebar')} (<span class="code">${process.platform === 'darwin' ? 'Cmd+Shift+S' : 'Ctrl+Shift+S'}</span>)</div>
+          <div class="setting-description">
+            ${t.__("Show sidebar")} (<span class="code"
+              >${process.platform === "darwin"
+                ? "Cmd+Shift+S"
+                : "Ctrl+Shift+S"}</span
+            >)
+          </div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="badge-option">
-						<div class="setting-description">${t.__('Show app unread badge')}</div>
+          <div class="setting-description">
+            ${t.__("Show app unread badge")}
+          </div>
           <div class="setting-control"></div>
         </div>
-					<div class="setting-row" id="dock-bounce-option" style= "display:${process.platform === 'darwin' ? '' : 'none'}">
+        <div
-						<div class="setting-description">${t.__('Bounce dock on new private message')}</div>
+          class="setting-row"
+          id="dock-bounce-option"
+          style="display:${process.platform === "darwin" ? "" : "none"}"
+        >
+          <div class="setting-description">
+            ${t.__("Bounce dock on new private message")}
+          </div>
           <div class="setting-control"></div>
         </div>
-					<div class="setting-row" id="flash-taskbar-option" style= "display:${process.platform === 'win32' ? '' : 'none'}">
+        <div
-						<div class="setting-description">${t.__('Flash taskbar on new message')}</div>
+          class="setting-row"
+          id="flash-taskbar-option"
+          style="display:${process.platform === "win32" ? "" : "none"}"
+        >
+          <div class="setting-description">
+            ${t.__("Flash taskbar on new message")}
+          </div>
           <div class="setting-control"></div>
         </div>
       </div>
-				<div class="title">${t.__('Desktop Notifications')}</div>
+      <div class="title">${t.__("Desktop Notifications")}</div>
       <div class="settings-card">
         <div class="setting-row" id="show-notification-option">
-						<div class="setting-description">${t.__('Show desktop notifications')}</div>
+          <div class="setting-description">
+            ${t.__("Show desktop notifications")}
+          </div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="silent-option">
-						<div class="setting-description">${t.__('Mute all sounds from Zulip')}</div>
+          <div class="setting-description">
+            ${t.__("Mute all sounds from Zulip")}
+          </div>
           <div class="setting-control"></div>
         </div>
       </div>
-				<div class="title">${t.__('App Updates')}</div>
+      <div class="title">${t.__("App Updates")}</div>
       <div class="settings-card">
         <div class="setting-row" id="autoupdate-option">
-						<div class="setting-description">${t.__('Enable auto updates')}</div>
+          <div class="setting-description">${t.__("Enable auto updates")}</div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="betaupdate-option">
-						<div class="setting-description">${t.__('Get beta updates')}</div>
+          <div class="setting-description">${t.__("Get beta updates")}</div>
           <div class="setting-control"></div>
         </div>
       </div>
-				<div class="title">${t.__('Functionality')}</div>
+      <div class="title">${t.__("Functionality")}</div>
       <div class="settings-card">
         <div class="setting-row" id="startAtLogin-option">
-						<div class="setting-description">${t.__('Start app at login')}</div>
+          <div class="setting-description">${t.__("Start app at login")}</div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="start-minimize-option">
-						<div class="setting-description">${t.__('Always start minimized')}</div>
+          <div class="setting-description">
+            ${t.__("Always start minimized")}
+          </div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="quitOnClose-option">
-						<div class="setting-description">${t.__('Quit when the window is closed')}</div>
+          <div class="setting-description">
+            ${t.__("Quit when the window is closed")}
+          </div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="enable-spellchecker-option">
-						<div class="setting-description">${t.__('Enable spellchecker (requires restart)')}</div>
+          <div class="setting-description">
+            ${t.__("Enable spellchecker (requires restart)")}
+          </div>
           <div class="setting-control"></div>
         </div>
+        <div
+          class="setting-row"
+          id="spellcheck-langs"
+          style="display:${process.platform === "darwin" ? "none" : ""}"
+        ></div>
+        <div class="setting-row" id="note"></div>
       </div>
-				<div class="title">${t.__('Advanced')}</div>
-				<div class="settings-card">
 
+      <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-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 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">
+          <div class="setting-description">${t.__("Add custom CSS")}</div>
-							${t.__('Add custom CSS')}
+          <button class="custom-css-button green">${t.__("Upload")}</button>
-						</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 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>
+            <span>${t.__("Delete")}</span>
           </div>
         </div>
         <div class="setting-row" id="download-folder">
           <div class="setting-description">
-							${t.__('Default download location')}
+            ${t.__("Default download location")}
           </div>
-						<button class="download-folder-button green">${t.__('Change')}</button>
+          <button class="download-folder-button green">
+            ${t.__("Change")}
+          </button>
         </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.getConfigItem(
+                "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-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="title">${t.__("Factory Reset Data")}</div>
       <div class="settings-card">
-					<div class="setting-row" id="resetdata-option">
+        <div class="setting-row" id="factory-reset-option">
-						<div class="setting-description">${t.__('This will delete all application data including all added accounts and preferences')}
+          <div class="setting-description">
+            ${t.__(
+              "Reset the application, thus deleting all the connected organizations and accounts.",
+            )}
           </div>
-						<button class="reset-data-button red w-150">${t.__('Reset App Data')}</button>
+          <button class="factory-reset-button red w-150">
+            ${t.__("Factory Reset")}
+          </button>
         </div>
       </div>
     </div>
-		`;
+  `.html;
-	}
 
-	init(): void {
+  updateTrayOption();
-		this.props.$root.innerHTML = this.template();
+  updateBadgeOption();
-		this.updateTrayOption();
+  updateSilentOption();
-		this.updateBadgeOption();
+  autoUpdateOption();
-		this.updateSilentOption();
+  betaUpdateOption();
-		this.autoUpdateOption();
+  updateSidebarOption();
-		this.betaUpdateOption();
+  updateStartAtLoginOption();
-		this.updateSidebarOption();
+  factoryReset();
-		this.updateStartAtLoginOption();
+  showDesktopNotification();
-		this.updateResetDataOption();
+  enableSpellchecker();
-		this.showDesktopNotification();
+  minimizeOnStart();
-		this.enableSpellchecker();
+  addCustomCss();
-		this.minimizeOnStart();
+  showCustomCssPath();
-		this.addCustomCSS();
+  removeCustomCss();
-		this.showCustomCSSPath();
+  downloadFolder();
-		this.removeCustomCSS();
+  updateQuitOnCloseOption();
-		this.downloadFolder();
+  updatePromptDownloadOption();
-		this.updateQuitOnCloseOption();
+  enableErrorReporting();
-		this.updatePromptDownloadOption();
+  setLocale();
-		this.enableErrorReporting();
+  initSpellChecker();
-		this.setLocale();
 
   // Platform specific settings
 
   // Flashing taskbar on Windows
-		if (process.platform === 'win32') {
+  if (process.platform === "win32") {
-			this.updateFlashTaskbar();
+    updateFlashTaskbar();
   }
+
   // Dock bounce on macOS
-		if (process.platform === 'darwin') {
+  if (process.platform === "darwin") {
-			this.updateDockBouncing();
+    updateDockBouncing();
   }
 
   // Auto hide menubar on Windows and Linux
-		if (process.platform !== 'darwin') {
+  if (process.platform !== "darwin") {
-			this.updateMenubarOption();
+    updateMenubarOption();
-		}
   }
 
-	updateTrayOption(): void {
+  function updateTrayOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#tray-option .setting-control'),
+      $element: $root.querySelector("#tray-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('trayIcon', true),
+      value: ConfigUtil.getConfigItem("trayIcon", true),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('trayIcon');
+        const newValue = !ConfigUtil.getConfigItem("trayIcon", true);
-				ConfigUtil.setConfigItem('trayIcon', newValue);
+        ConfigUtil.setConfigItem("trayIcon", newValue);
-				ipcRenderer.send('forward-message', 'toggletray');
+        ipcRenderer.send("forward-message", "toggletray");
-				this.updateTrayOption();
+        updateTrayOption();
-			}
+      },
     });
   }
 
-	updateMenubarOption(): void {
+  function updateMenubarOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#menubar-option .setting-control'),
+      $element: $root.querySelector("#menubar-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('autoHideMenubar', false),
+      value: ConfigUtil.getConfigItem("autoHideMenubar", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('autoHideMenubar');
+        const newValue = !ConfigUtil.getConfigItem("autoHideMenubar", false);
-				ConfigUtil.setConfigItem('autoHideMenubar', newValue);
+        ConfigUtil.setConfigItem("autoHideMenubar", newValue);
-				ipcRenderer.send('toggle-menubar', newValue);
+        ipcRenderer.send("toggle-menubar", newValue);
-				this.updateMenubarOption();
+        updateMenubarOption();
-			}
+      },
     });
   }
 
-	updateBadgeOption(): void {
+  function updateBadgeOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#badge-option .setting-control'),
+      $element: $root.querySelector("#badge-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('badgeOption', true),
+      value: ConfigUtil.getConfigItem("badgeOption", true),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('badgeOption');
+        const newValue = !ConfigUtil.getConfigItem("badgeOption", true);
-				ConfigUtil.setConfigItem('badgeOption', newValue);
+        ConfigUtil.setConfigItem("badgeOption", newValue);
-				ipcRenderer.send('toggle-badge-option', newValue);
+        ipcRenderer.send("toggle-badge-option", newValue);
-				this.updateBadgeOption();
+        updateBadgeOption();
-			}
+      },
     });
   }
 
-	updateDockBouncing(): void {
+  function updateDockBouncing(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#dock-bounce-option .setting-control'),
+      $element: $root.querySelector("#dock-bounce-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('dockBouncing', true),
+      value: ConfigUtil.getConfigItem("dockBouncing", true),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('dockBouncing');
+        const newValue = !ConfigUtil.getConfigItem("dockBouncing", true);
-				ConfigUtil.setConfigItem('dockBouncing', newValue);
+        ConfigUtil.setConfigItem("dockBouncing", newValue);
-				this.updateDockBouncing();
+        updateDockBouncing();
-			}
+      },
     });
   }
 
-	updateFlashTaskbar(): void {
+  function updateFlashTaskbar(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#flash-taskbar-option .setting-control'),
+      $element: $root.querySelector("#flash-taskbar-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('flashTaskbarOnMessage', true),
+      value: ConfigUtil.getConfigItem("flashTaskbarOnMessage", true),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('flashTaskbarOnMessage');
+        const newValue = !ConfigUtil.getConfigItem(
-				ConfigUtil.setConfigItem('flashTaskbarOnMessage', newValue);
+          "flashTaskbarOnMessage",
-				this.updateFlashTaskbar();
+          true,
-			}
+        );
+        ConfigUtil.setConfigItem("flashTaskbarOnMessage", newValue);
+        updateFlashTaskbar();
+      },
     });
   }
 
-	autoUpdateOption(): void {
+  function autoUpdateOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#autoupdate-option .setting-control'),
+      $element: $root.querySelector("#autoupdate-option .setting-control")!,
-			disabled: EnterpriseUtil.configItemExists('autoUpdate'),
+      disabled: EnterpriseUtil.configItemExists("autoUpdate"),
-			value: ConfigUtil.getConfigItem('autoUpdate', true),
+      value: ConfigUtil.getConfigItem("autoUpdate", true),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('autoUpdate');
+        const newValue = !ConfigUtil.getConfigItem("autoUpdate", true);
-				ConfigUtil.setConfigItem('autoUpdate', newValue);
+        ConfigUtil.setConfigItem("autoUpdate", newValue);
         if (!newValue) {
-					ConfigUtil.setConfigItem('betaUpdate', false);
+          ConfigUtil.setConfigItem("betaUpdate", false);
-					this.betaUpdateOption();
+          betaUpdateOption();
-				}
-				this.autoUpdateOption();
         }
+
+        autoUpdateOption();
+      },
     });
   }
 
-	betaUpdateOption(): void {
+  function betaUpdateOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#betaupdate-option .setting-control'),
+      $element: $root.querySelector("#betaupdate-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('betaUpdate', false),
+      value: ConfigUtil.getConfigItem("betaUpdate", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('betaUpdate');
+        const newValue = !ConfigUtil.getConfigItem("betaUpdate", false);
-				if (ConfigUtil.getConfigItem('autoUpdate')) {
+        if (ConfigUtil.getConfigItem("autoUpdate", true)) {
-					ConfigUtil.setConfigItem('betaUpdate', newValue);
+          ConfigUtil.setConfigItem("betaUpdate", newValue);
-					this.betaUpdateOption();
+          betaUpdateOption();
-				}
         }
+      },
     });
   }
 
-	updateSilentOption(): void {
+  function updateSilentOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#silent-option .setting-control'),
+      $element: $root.querySelector("#silent-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('silent', false),
+      value: ConfigUtil.getConfigItem("silent", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('silent', true);
+        const newValue = !ConfigUtil.getConfigItem("silent", true);
-				ConfigUtil.setConfigItem('silent', newValue);
+        ConfigUtil.setConfigItem("silent", newValue);
-				this.updateSilentOption();
+        updateSilentOption();
-				currentBrowserWindow.webContents.send('toggle-silent', newValue);
+        ipcRenderer.sendTo(
-			}
+          currentBrowserWindow.webContents.id,
+          "toggle-silent",
+          newValue,
+        );
+      },
     });
   }
 
-	showDesktopNotification(): void {
+  function showDesktopNotification(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#show-notification-option .setting-control'),
+      $element: $root.querySelector(
-			value: ConfigUtil.getConfigItem('showNotification', true),
+        "#show-notification-option .setting-control",
-			clickHandler: () => {
+      )!,
-				const newValue = !ConfigUtil.getConfigItem('showNotification', true);
+      value: ConfigUtil.getConfigItem("showNotification", true),
-				ConfigUtil.setConfigItem('showNotification', newValue);
+      clickHandler() {
-				this.showDesktopNotification();
+        const newValue = !ConfigUtil.getConfigItem("showNotification", true);
-			}
+        ConfigUtil.setConfigItem("showNotification", newValue);
+        showDesktopNotification();
+      },
     });
   }
 
-	updateSidebarOption(): void {
+  function updateSidebarOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#sidebar-option .setting-control'),
+      $element: $root.querySelector("#sidebar-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('showSidebar', true),
+      value: ConfigUtil.getConfigItem("showSidebar", true),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('showSidebar');
+        const newValue = !ConfigUtil.getConfigItem("showSidebar", true);
-				ConfigUtil.setConfigItem('showSidebar', newValue);
+        ConfigUtil.setConfigItem("showSidebar", newValue);
-				ipcRenderer.send('forward-message', 'toggle-sidebar', newValue);
+        ipcRenderer.send("forward-message", "toggle-sidebar", newValue);
-				this.updateSidebarOption();
+        updateSidebarOption();
-			}
+      },
     });
   }
 
-	updateStartAtLoginOption(): void {
+  function updateStartAtLoginOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#startAtLogin-option .setting-control'),
+      $element: $root.querySelector("#startAtLogin-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('startAtLogin', false),
+      value: ConfigUtil.getConfigItem("startAtLogin", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('startAtLogin');
+        const newValue = !ConfigUtil.getConfigItem("startAtLogin", false);
-				ConfigUtil.setConfigItem('startAtLogin', newValue);
+        ConfigUtil.setConfigItem("startAtLogin", newValue);
-				ipcRenderer.send('toggleAutoLauncher', newValue);
+        ipcRenderer.send("toggleAutoLauncher", newValue);
-				this.updateStartAtLoginOption();
+        updateStartAtLoginOption();
-			}
+      },
     });
   }
 
-	updateQuitOnCloseOption(): void {
+  function updateQuitOnCloseOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#quitOnClose-option .setting-control'),
+      $element: $root.querySelector("#quitOnClose-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('quitOnClose', false),
+      value: ConfigUtil.getConfigItem("quitOnClose", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('quitOnClose');
+        const newValue = !ConfigUtil.getConfigItem("quitOnClose", false);
-				ConfigUtil.setConfigItem('quitOnClose', newValue);
+        ConfigUtil.setConfigItem("quitOnClose", newValue);
-				this.updateQuitOnCloseOption();
+        updateQuitOnCloseOption();
-			}
+      },
     });
   }
 
-	enableSpellchecker(): void {
+  function enableSpellchecker(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#enable-spellchecker-option .setting-control'),
+      $element: $root.querySelector(
-			value: ConfigUtil.getConfigItem('enableSpellchecker', true),
+        "#enable-spellchecker-option .setting-control",
-			clickHandler: () => {
+      )!,
-				const newValue = !ConfigUtil.getConfigItem('enableSpellchecker');
+      value: ConfigUtil.getConfigItem("enableSpellchecker", true),
-				ConfigUtil.setConfigItem('enableSpellchecker', newValue);
+      clickHandler() {
-				this.enableSpellchecker();
+        const newValue = !ConfigUtil.getConfigItem("enableSpellchecker", true);
-			}
+        ConfigUtil.setConfigItem("enableSpellchecker", newValue);
+        ipcRenderer.send("configure-spell-checker");
+        enableSpellchecker();
+        const spellcheckerLanguageInput: HTMLElement =
+          $root.querySelector("#spellcheck-langs")!;
+        const spellcheckerNote: HTMLElement = $root.querySelector("#note")!;
+        spellcheckerLanguageInput.style.display =
+          spellcheckerLanguageInput.style.display === "none" ? "" : "none";
+        spellcheckerNote.style.display =
+          spellcheckerNote.style.display === "none" ? "" : "none";
+      },
     });
   }
 
-	enableErrorReporting(): void {
+  function enableErrorReporting(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#enable-error-reporting .setting-control'),
+      $element: $root.querySelector(
-			value: ConfigUtil.getConfigItem('errorReporting', true),
+        "#enable-error-reporting .setting-control",
-			clickHandler: () => {
+      )!,
-				const newValue = !ConfigUtil.getConfigItem('errorReporting');
+      value: ConfigUtil.getConfigItem("errorReporting", true),
-				ConfigUtil.setConfigItem('errorReporting', newValue);
+      clickHandler() {
-				this.enableErrorReporting();
+        const newValue = !ConfigUtil.getConfigItem("errorReporting", true);
-			}
+        ConfigUtil.setConfigItem("errorReporting", newValue);
+        enableErrorReporting();
+      },
     });
   }
 
-	async clearAppDataDialog(): Promise<void> {
+  async function customCssDialog(): 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.name);
-
-		const { response } = await dialog.showMessageBox({
-			type: 'warning',
-			buttons: ['YES', 'NO'],
-			defaultId: 0,
-			message: 'Are you sure',
-			detail: clearAppDataMessage
-		});
-		if (response === 0) {
-			fs.remove(getAppPath);
-			setTimeout(() => ipcRenderer.send('forward-message', 'hard-reload'), 1000);
-		}
-	}
-
-	async customCssDialog(): Promise<void> {
     const showDialogOptions: OpenDialogOptions = {
-			title: 'Select file',
+      title: "Select file",
-			properties: ['openFile'],
+      properties: ["openFile"],
-			filters: [{ name: 'CSS file', extensions: ['css'] }]
+      filters: [{name: "CSS file", extensions: ["css"]}],
     };
 
-		const { filePaths, canceled } = await dialog.showOpenDialog(showDialogOptions);
+    const {filePaths, canceled} = await dialog.showOpenDialog(
+      showDialogOptions,
+    );
     if (!canceled) {
-			ConfigUtil.setConfigItem('customCSS', filePaths[0]);
+      ConfigUtil.setConfigItem("customCSS", filePaths[0]);
-			ipcRenderer.send('forward-message', 'hard-reload');
+      ipcRenderer.send("forward-message", "hard-reload");
     }
   }
 
-	updateResetDataOption(): void {
+  function setLocale(): void {
-		const resetDataButton = document.querySelector('#resetdata-option .reset-data-button');
+    const langDiv: HTMLSelectElement = $root.querySelector(".lang-div")!;
-		resetDataButton.addEventListener('click', () => {
+    const langListHtml = generateSelectHtml(supportedLocales, "lang-menu");
-			this.clearAppDataDialog();
+    langDiv.innerHTML += langListHtml.html;
-		});
+    // `langMenu` is the select-option dropdown menu formed after executing the previous command
-	}
+    const langMenu: HTMLSelectElement = $root.querySelector(".lang-menu")!;
-
-	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');
+    let language = ConfigUtil.getConfigItem("appLanguage", "en");
-		language = language && langMenu.options.namedItem(language) ? language : 'en-US';
+    language =
-		langMenu.options.namedItem(language).selected = true;
+      language && langMenu.options.namedItem(language) ? language : "en";
+    langMenu.options.namedItem(language)!.selected = true;
 
-		langMenu.addEventListener('change', (event: Event) => {
+    langMenu.addEventListener("change", () => {
-			ConfigUtil.setConfigItem('appLanguage', (event.target as HTMLSelectElement).value);
+      ConfigUtil.setConfigItem("appLanguage", langMenu.value);
     });
   }
 
-	minimizeOnStart(): void {
+  function minimizeOnStart(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#start-minimize-option .setting-control'),
+      $element: $root.querySelector("#start-minimize-option .setting-control")!,
-			value: ConfigUtil.getConfigItem('startMinimized', false),
+      value: ConfigUtil.getConfigItem("startMinimized", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('startMinimized');
+        const newValue = !ConfigUtil.getConfigItem("startMinimized", false);
-				ConfigUtil.setConfigItem('startMinimized', newValue);
+        ConfigUtil.setConfigItem("startMinimized", newValue);
-				this.minimizeOnStart();
+        minimizeOnStart();
-			}
+      },
     });
   }
 
-	addCustomCSS(): void {
+  function addCustomCss(): void {
-		const customCSSButton = document.querySelector('#add-custom-css .custom-css-button');
+    const customCssButton = $root.querySelector(
-		customCSSButton.addEventListener('click', () => {
+      "#add-custom-css .custom-css-button",
-			this.customCssDialog();
+    )!;
+    customCssButton.addEventListener("click", async () => {
+      await customCssDialog();
     });
   }
 
-	showCustomCSSPath(): void {
+  function showCustomCssPath(): void {
-		if (!ConfigUtil.getConfigItem('customCSS')) {
+    if (!ConfigUtil.getConfigItem("customCSS", null)) {
-			const cssPATH: HTMLElement = document.querySelector('#remove-custom-css');
+      const cssPath: HTMLElement = $root.querySelector("#remove-custom-css")!;
-			cssPATH.style.display = 'none';
+      cssPath.style.display = "none";
     }
   }
 
-	removeCustomCSS(): void {
+  function removeCustomCss(): void {
-		const removeCSSButton = document.querySelector('#css-delete-action');
+    const removeCssButton = $root.querySelector("#css-delete-action")!;
-		removeCSSButton.addEventListener('click', () => {
+    removeCssButton.addEventListener("click", () => {
-			ConfigUtil.setConfigItem('customCSS', '');
+      ConfigUtil.setConfigItem("customCSS", "");
-			ipcRenderer.send('forward-message', 'hard-reload');
+      ipcRenderer.send("forward-message", "hard-reload");
     });
   }
 
-	async downloadFolderDialog(): Promise<void> {
+  async function downloadFolderDialog(): Promise<void> {
     const showDialogOptions: OpenDialogOptions = {
-			title: 'Select Download Location',
+      title: "Select Download Location",
-			properties: ['openDirectory']
+      properties: ["openDirectory"],
     };
 
-		const { filePaths, canceled } = await dialog.showOpenDialog(showDialogOptions);
+    const {filePaths, canceled} = await dialog.showOpenDialog(
+      showDialogOptions,
+    );
     if (!canceled) {
-			ConfigUtil.setConfigItem('downloadsPath', filePaths[0]);
+      ConfigUtil.setConfigItem("downloadsPath", filePaths[0]);
-			const downloadFolderPath: HTMLElement = document.querySelector('.download-folder-path');
+      const downloadFolderPath: HTMLElement = $root.querySelector(
+        ".download-folder-path",
+      )!;
       downloadFolderPath.textContent = filePaths[0];
     }
   }
 
-	downloadFolder(): void {
+  function downloadFolder(): void {
-		const downloadFolder = document.querySelector('#download-folder .download-folder-button');
+    const downloadFolder = $root.querySelector(
-		downloadFolder.addEventListener('click', () => {
+      "#download-folder .download-folder-button",
-			this.downloadFolderDialog();
+    )!;
+    downloadFolder.addEventListener("click", async () => {
+      await downloadFolderDialog();
     });
   }
 
-	updatePromptDownloadOption(): void {
+  function updatePromptDownloadOption(): void {
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#prompt-download .setting-control'),
+      $element: $root.querySelector("#prompt-download .setting-control")!,
-			value: ConfigUtil.getConfigItem('promptDownload', false),
+      value: ConfigUtil.getConfigItem("promptDownload", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('promptDownload');
+        const newValue = !ConfigUtil.getConfigItem("promptDownload", false);
-				ConfigUtil.setConfigItem('promptDownload', newValue);
+        ConfigUtil.setConfigItem("promptDownload", newValue);
-				this.updatePromptDownloadOption();
+        updatePromptDownloadOption();
+      },
+    });
+  }
+
+  async function factoryResetSettings(): Promise<void> {
+    const clearAppDataMessage =
+      "When the application restarts, it will be as if you have just downloaded Zulip app.";
+    const getAppPath = path.join(app.getPath("appData"), app.name);
+
+    const {response} = await dialog.showMessageBox({
+      type: "warning",
+      buttons: ["YES", "NO"],
+      defaultId: 0,
+      message: "Are you sure?",
+      detail: clearAppDataMessage,
+    });
+    if (response === 0) {
+      await fs.promises.rmdir(getAppPath, {recursive: true});
+      setTimeout(() => {
+        ipcRenderer.send("clear-app-settings");
+      }, 1000);
+    }
+  }
+
+  function factoryReset(): void {
+    const factoryResetButton = $root.querySelector(
+      "#factory-reset-option .factory-reset-button",
+    )!;
+    factoryResetButton.addEventListener("click", async () => {
+      await factoryResetSettings();
+    });
+  }
+
+  function initSpellChecker(): void {
+    // The elctron API is a no-op on macOS and macOS default spellchecker is used.
+    if (process.platform === "darwin") {
+      const note: HTMLElement = $root.querySelector("#note")!;
+      note.append(t.__("On macOS, the OS spellchecker is used."));
+      note.append(document.createElement("br"));
+      note.append(
+        t.__(
+          "Change the language from System Preferences → Keyboard → Text → Spelling.",
+        ),
+      );
+    } else {
+      const note: HTMLElement = $root.querySelector("#note")!;
+      note.append(
+        t.__("You can select a maximum of 3 languages for spellchecking."),
+      );
+      const spellDiv: HTMLElement = $root.querySelector("#spellcheck-langs")!;
+      spellDiv.innerHTML += html`
+        <div class="setting-description">${t.__("Spellchecker Languages")}</div>
+        <input name="spellcheck" placeholder="Enter Languages" />
+      `.html;
+
+      const availableLanguages = session.fromPartition(
+        "persist:webviewsession",
+      ).availableSpellCheckerLanguages;
+      let languagePairs: Map<string, string> = new Map();
+      for (const l of availableLanguages) {
+        if (ISO6391.validate(l)) {
+          languagePairs.set(ISO6391.getName(l), l);
+        }
+      }
+
+      // Manually set names for languages not available in ISO6391
+      languagePairs.set("English (AU)", "en-AU");
+      languagePairs.set("English (CA)", "en-CA");
+      languagePairs.set("English (GB)", "en-GB");
+      languagePairs.set("English (US)", "en-US");
+      languagePairs.set("Spanish (Latin America)", "es-419");
+      languagePairs.set("Spanish (Argentina)", "es-AR");
+      languagePairs.set("Spanish (Mexico)", "es-MX");
+      languagePairs.set("Spanish (US)", "es-US");
+      languagePairs.set("Portuguese (Brazil)", "pt-BR");
+      languagePairs.set("Portuguese (Portugal)", "pt-PT");
+      languagePairs.set("Serbo-Croatian", "sh");
+
+      languagePairs = new Map(
+        [...languagePairs].sort((a, b) => (a[0] < b[0] ? -1 : 1)),
+      );
+
+      const tagField: HTMLInputElement = $root.querySelector(
+        "input[name=spellcheck]",
+      )!;
+      const tagify = new Tagify(tagField, {
+        whitelist: [...languagePairs.keys()],
+        enforceWhitelist: true,
+        maxTags: 3,
+        dropdown: {
+          enabled: 0,
+          maxItems: Number.POSITIVE_INFINITY,
+          closeOnSelect: false,
+          highlightFirst: true,
+        },
+      });
+
+      const configuredLanguages: string[] = (
+        ConfigUtil.getConfigItem("spellcheckerLanguages", null) ?? []
+      ).map(
+        (code: string) =>
+          [...languagePairs].find((pair) => pair[1] === code)![0],
+      );
+      tagify.addTags(configuredLanguages);
+
+      tagField.addEventListener("change", () => {
+        if (tagField.value.length === 0) {
+          ConfigUtil.setConfigItem("spellcheckerLanguages", []);
+          ipcRenderer.send("configure-spell-checker");
+        } else {
+          const data: unknown = JSON.parse(tagField.value);
+          const spellLangs: string[] = z
+            .array(z.object({value: z.string()}))
+            .parse(data)
+            .map((elt) => languagePairs.get(elt.value)!);
+          ConfigUtil.setConfigItem("spellcheckerLanguages", spellLangs);
+          ipcRenderer.send("configure-spell-checker");
         }
       });
     }
+
+    // Do not display the spellchecker input and note if it is disabled
+    if (!ConfigUtil.getConfigItem("enableSpellchecker", true)) {
+      const spellcheckerLanguageInput: HTMLElement =
+        $root.querySelector("#spellcheck-langs")!;
+      const spellcheckerNote: HTMLElement = $root.querySelector("#note")!;
+      spellcheckerLanguageInput.style.display = "none";
+      spellcheckerNote.style.display = "none";
+    }
+  }
 }

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

@@ -1,52 +1,60 @@
-import BaseComponent from '../../components/base';
+import type {Html} from "../../../../common/html";
-import * as t from '../../utils/translation-util';
+import {html} from "../../../../common/html";
+import * as t from "../../../../common/translation-util";
+import type {NavItem} from "../../../../common/types";
+import {generateNodeFromHtml} from "../../components/base";
 
 interface PreferenceNavProps {
   $root: Element;
-	onItemSelected: (navItem: string) => void;
+  onItemSelected: (navItem: NavItem) => void;
 }
 
-export default class PreferenceNav extends BaseComponent {
+export default class PreferenceNav {
   props: PreferenceNavProps;
-	navItems: string[];
+  navItems: NavItem[];
   $el: Element;
   constructor(props: PreferenceNavProps) {
-		super();
     this.props = props;
-		this.navItems = ['General', 'Network', 'AddServer', 'Organizations', 'Shortcuts'];
+    this.navItems = [
-		this.init();
+      "General",
-	}
+      "Network",
+      "AddServer",
+      "Organizations",
+      "Shortcuts",
+    ];
 
-	template(): string {
+    this.$el = generateNodeFromHtml(this.templateHtml());
-		let navItemsTemplate = '';
-		for (const navItem of this.navItems) {
-			navItemsTemplate += `<div class="nav" id="nav-${navItem}">${t.__(navItem)}</div>`;
-		}
-
-		return `
-			<div>
-				<div id="settings-header">${t.__('Settings')}</div>
-				<div id="nav-container">${navItemsTemplate}</div>
-			</div>
-		`;
-	}
-
-	init(): void {
-		this.$el = this.generateNodeFromTemplate(this.template());
     this.props.$root.append(this.$el);
     this.registerListeners();
   }
 
+  templateHtml(): Html {
+    const navItemsHtml = html``.join(
+      this.navItems.map(
+        (navItem) => html`
+          <div class="nav" id="nav-${navItem}">${t.__(navItem)}</div>
+        `,
+      ),
+    );
+
+    return html`
+      <div>
+        <div id="settings-header">${t.__("Settings")}</div>
+        <div id="nav-container">${navItemsHtml}</div>
+      </div>
+    `;
+  }
+
   registerListeners(): void {
     for (const navItem of this.navItems) {
-			const $item = document.querySelector(`#nav-${navItem}`);
+      const $item = this.$el.querySelector(`#nav-${CSS.escape(navItem)}`)!;
-			$item.addEventListener('click', () => {
+      $item.addEventListener("click", () => {
         this.props.onItemSelected(navItem);
       });
     }
   }
 
-	select(navItemToSelect: string): void {
+  select(navItemToSelect: NavItem): void {
     for (const navItem of this.navItems) {
       if (navItem === navItemToSelect) {
         this.activate(navItem);
@@ -56,13 +64,13 @@ export default class PreferenceNav extends BaseComponent {
     }
   }
 
-	activate(navItem: string): void {
+  activate(navItem: NavItem): void {
-		const $item = document.querySelector(`#nav-${navItem}`);
+    const $item = this.$el.querySelector(`#nav-${CSS.escape(navItem)}`)!;
-		$item.classList.add('active');
+    $item.classList.add("active");
   }
 
-	deactivate(navItem: string): void {
+  deactivate(navItem: NavItem): void {
-		const $item = document.querySelector(`#nav-${navItem}`);
+    const $item = this.$el.querySelector(`#nav-${CSS.escape(navItem)}`)!;
-		$item.classList.remove('active');
+    $item.classList.remove("active");
   }
 }

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

@@ -1,135 +1,136 @@
-import { ipcRenderer } from 'electron';
+import * as ConfigUtil from "../../../../common/config-util";
+import {html} from "../../../../common/html";
+import * as t from "../../../../common/translation-util";
+import {ipcRenderer} from "../../typed-ipc-renderer";
 
-import BaseSection from './base-section';
+import {generateSettingOption} from "./base-section";
-import * as ConfigUtil from '../../utils/config-util';
-import * as t from '../../utils/translation-util';
 
 interface NetworkSectionProps {
   $root: Element;
 }
 
-export default class NetworkSection extends BaseSection {
+export function initNetworkSection({$root}: NetworkSectionProps): void {
-	props: NetworkSectionProps;
+  $root.innerHTML = html`
-	$proxyPAC: HTMLInputElement;
-	$proxyRules: HTMLInputElement;
-	$proxyBypass: HTMLInputElement;
-	$proxySaveAction: Element;
-	$manualProxyBlock: Element;
-	constructor(props: NetworkSectionProps) {
-		super();
-		this.props = props;
-	}
-
-	template(): string {
-		return `
     <div class="settings-pane">
-                <div class="title">${t.__('Proxy')}</div>
+      <div class="title">${t.__("Proxy")}</div>
       <div id="appearance-option-settings" class="settings-card">
         <div class="setting-row" id="use-system-settings">
-						<div class="setting-description">${t.__('Use system proxy settings (requires restart)')}</div>
+          <div class="setting-description">
+            ${t.__("Use system proxy settings (requires restart)")}
+          </div>
           <div class="setting-control"></div>
         </div>
         <div class="setting-row" id="use-manual-settings">
-						<div class="setting-description">${t.__('Manual proxy configuration')}</div>
+          <div class="setting-description">
+            ${t.__("Manual proxy configuration")}
+          </div>
           <div class="setting-control"></div>
         </div>
         <div class="manual-proxy-block">
           <div class="setting-row" id="proxy-pac-option">
-							<span class="setting-input-key">PAC ${t.__('script')}</span>
+            <span class="setting-input-key">PAC ${t.__("script")}</span>
-							<input class="setting-input-value" placeholder="e.g. foobar.com/pacfile.js"/>
+            <input
+              class="setting-input-value"
+              placeholder="e.g. foobar.com/pacfile.js"
+            />
           </div>
           <div class="setting-row" id="proxy-rules-option">
-							<span class="setting-input-key">${t.__('Proxy rules')}</span>
+            <span class="setting-input-key">${t.__("Proxy rules")}</span>
-							<input class="setting-input-value" placeholder="e.g. http=foopy:80;ftp=foopy2"/>
+            <input
+              class="setting-input-value"
+              placeholder="e.g. http=foopy:80;ftp=foopy2"
+            />
           </div>
           <div class="setting-row" id="proxy-bypass-option">
-							<span class="setting-input-key">${t.__('Proxy bypass rules')}</span>
+            <span class="setting-input-key">${t.__("Proxy bypass rules")}</span>
-							<input class="setting-input-value" placeholder="e.g. foobar.com"/>
+            <input class="setting-input-value" placeholder="e.g. foobar.com" />
           </div>
           <div class="setting-row">
             <div class="action green" id="proxy-save-action">
-								<span>${t.__('Save')}</span>
+              <span>${t.__("Save")}</span>
             </div>
           </div>
         </div>
       </div>
     </div>
-		`;
+  `.html;
-	}
 
-	init(): void {
+  const $proxyPac: HTMLInputElement = $root.querySelector(
-		this.props.$root.innerHTML = this.template();
+    "#proxy-pac-option .setting-input-value",
-		this.$proxyPAC = document.querySelector('#proxy-pac-option .setting-input-value');
+  )!;
-		this.$proxyRules = document.querySelector('#proxy-rules-option .setting-input-value');
+  const $proxyRules: HTMLInputElement = $root.querySelector(
-		this.$proxyBypass = document.querySelector('#proxy-bypass-option .setting-input-value');
+    "#proxy-rules-option .setting-input-value",
-		this.$proxySaveAction = document.querySelector('#proxy-save-action');
+  )!;
-		this.$manualProxyBlock = this.props.$root.querySelector('.manual-proxy-block');
+  const $proxyBypass: HTMLInputElement = $root.querySelector(
-		this.initProxyOption();
+    "#proxy-bypass-option .setting-input-value",
+  )!;
+  const $proxySaveAction = $root.querySelector("#proxy-save-action")!;
+  const $manualProxyBlock = $root.querySelector(".manual-proxy-block")!;
 
-		this.$proxyPAC.value = ConfigUtil.getConfigItem('proxyPAC', '');
+  toggleManualProxySettings(ConfigUtil.getConfigItem("useManualProxy", false));
-		this.$proxyRules.value = ConfigUtil.getConfigItem('proxyRules', '');
+  updateProxyOption();
-		this.$proxyBypass.value = ConfigUtil.getConfigItem('proxyBypass', '');
 
-		this.$proxySaveAction.addEventListener('click', () => {
+  $proxyPac.value = ConfigUtil.getConfigItem("proxyPAC", "");
-			ConfigUtil.setConfigItem('proxyPAC', this.$proxyPAC.value);
+  $proxyRules.value = ConfigUtil.getConfigItem("proxyRules", "");
-			ConfigUtil.setConfigItem('proxyRules', this.$proxyRules.value);
+  $proxyBypass.value = ConfigUtil.getConfigItem("proxyBypass", "");
-			ConfigUtil.setConfigItem('proxyBypass', this.$proxyBypass.value);
 
-			ipcRenderer.send('forward-message', 'reload-proxy', true);
+  $proxySaveAction.addEventListener("click", () => {
+    ConfigUtil.setConfigItem("proxyPAC", $proxyPac.value);
+    ConfigUtil.setConfigItem("proxyRules", $proxyRules.value);
+    ConfigUtil.setConfigItem("proxyBypass", $proxyBypass.value);
+
+    ipcRenderer.send("forward-message", "reload-proxy", true);
   });
+
+  function toggleManualProxySettings(option: boolean): void {
+    $manualProxyBlock.classList.toggle("hidden", !option);
   }
 
-	initProxyOption(): void {
+  function updateProxyOption(): void {
-		const manualProxyEnabled = ConfigUtil.getConfigItem('useManualProxy', false);
+    generateSettingOption({
-		this.toggleManualProxySettings(manualProxyEnabled);
+      $element: $root.querySelector("#use-system-settings .setting-control")!,
-
+      value: ConfigUtil.getConfigItem("useSystemProxy", false),
-		this.updateProxyOption();
+      clickHandler() {
-	}
+        const newValue = !ConfigUtil.getConfigItem("useSystemProxy", false);
-
+        const manualProxyValue = ConfigUtil.getConfigItem(
-	toggleManualProxySettings(option: boolean): void {
+          "useManualProxy",
-		if (option) {
+          false,
-			this.$manualProxyBlock.classList.remove('hidden');
+        );
-		} else {
-			this.$manualProxyBlock.classList.add('hidden');
-		}
-	}
-
-	updateProxyOption(): void {
-		this.generateSettingOption({
-			$element: document.querySelector('#use-system-settings .setting-control'),
-			value: ConfigUtil.getConfigItem('useSystemProxy', false),
-			clickHandler: () => {
-				const newValue = !ConfigUtil.getConfigItem('useSystemProxy');
-				const manualProxyValue = ConfigUtil.getConfigItem('useManualProxy');
         if (manualProxyValue && newValue) {
-					ConfigUtil.setConfigItem('useManualProxy', !manualProxyValue);
+          ConfigUtil.setConfigItem("useManualProxy", !manualProxyValue);
-					this.toggleManualProxySettings(!manualProxyValue);
+          toggleManualProxySettings(!manualProxyValue);
         }
+
         if (!newValue) {
           // Remove proxy system proxy settings
-					ConfigUtil.setConfigItem('proxyRules', '');
+          ConfigUtil.setConfigItem("proxyRules", "");
-					ipcRenderer.send('forward-message', 'reload-proxy', false);
+          ipcRenderer.send("forward-message", "reload-proxy", false);
-				}
-				ConfigUtil.setConfigItem('useSystemProxy', newValue);
-				this.updateProxyOption();
         }
+
+        ConfigUtil.setConfigItem("useSystemProxy", newValue);
+        updateProxyOption();
+      },
     });
-		this.generateSettingOption({
+    generateSettingOption({
-			$element: document.querySelector('#use-manual-settings .setting-control'),
+      $element: $root.querySelector("#use-manual-settings .setting-control")!,
-			value: ConfigUtil.getConfigItem('useManualProxy', false),
+      value: ConfigUtil.getConfigItem("useManualProxy", false),
-			clickHandler: () => {
+      clickHandler() {
-				const newValue = !ConfigUtil.getConfigItem('useManualProxy');
+        const newValue = !ConfigUtil.getConfigItem("useManualProxy", false);
-				const systemProxyValue = ConfigUtil.getConfigItem('useSystemProxy');
+        const systemProxyValue = ConfigUtil.getConfigItem(
-				this.toggleManualProxySettings(newValue);
+          "useSystemProxy",
+          false,
+        );
+        toggleManualProxySettings(newValue);
         if (systemProxyValue && newValue) {
-					ConfigUtil.setConfigItem('useSystemProxy', !systemProxyValue);
+          ConfigUtil.setConfigItem("useSystemProxy", !systemProxyValue);
         }
-				ConfigUtil.setConfigItem('proxyRules', '');
+
-				ConfigUtil.setConfigItem('useManualProxy', newValue);
+        ConfigUtil.setConfigItem("proxyRules", "");
+        ConfigUtil.setConfigItem("useManualProxy", newValue);
         // Reload app only when turning manual proxy off, hence !newValue
-				ipcRenderer.send('forward-message', 'reload-proxy', !newValue);
+        ipcRenderer.send("forward-message", "reload-proxy", !newValue);
-				this.updateProxyOption();
+        updateProxyOption();
-			}
+      },
     });
   }
 }

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

@@ -1,104 +1,103 @@
-import { ipcRenderer } from 'electron';
+import {dialog} from "@electron/remote";
 
-import BaseComponent from '../../components/base';
+import {html} from "../../../../common/html";
-import * as DomainUtil from '../../utils/domain-util';
+import * as LinkUtil from "../../../../common/link-util";
-import * as LinkUtil from '../../utils/link-util';
+import * as t from "../../../../common/translation-util";
-import * as t from '../../utils/translation-util';
+import {generateNodeFromHtml} from "../../components/base";
+import {ipcRenderer} from "../../typed-ipc-renderer";
+import * as DomainUtil from "../../utils/domain-util";
 
 interface NewServerFormProps {
   $root: Element;
   onChange: () => void;
 }
 
-export default class NewServerForm extends BaseComponent {
+export function initNewServerForm({$root, onChange}: NewServerFormProps): void {
-	props: NewServerFormProps;
+  const $newServerForm = generateNodeFromHtml(html`
-	$newServerForm: Element;
-	$saveServerButton: HTMLButtonElement;
-	$newServerUrl: HTMLInputElement;
-	constructor(props: NewServerFormProps) {
-		super();
-		this.props = props;
-	}
-
-	template(): string {
-		return `
     <div class="server-input-container">
-				<div class="title">${t.__('Organization URL')}</div>
+      <div class="title">${t.__("Organization URL")}</div>
       <div class="add-server-info-row">
-					<input class="setting-input-value" autofocus placeholder="your-organization.zulipchat.com or zulip.your-organization.com"/>
+        <input
+          class="setting-input-value"
+          autofocus
+          placeholder="your-organization.zulipchat.com or zulip.your-organization.com"
+        />
       </div>
       <div class="server-center">
-					<button id="connect">${t.__('Connect')}</button>
+        <button id="connect">${t.__("Connect")}</button>
       </div>
       <div class="server-center">
         <div class="divider">
-						<hr class="left"/>${t.__('OR')}<hr class="right" />
+          <hr class="left" />
+          ${t.__("OR")}
+          <hr class="right" />
         </div>
       </div>
       <div class="server-center">
-					<button id="open-create-org-link">${t.__('Create a new organization')}</button>
+        <button id="open-create-org-link">
+          ${t.__("Create a new organization")}
+        </button>
       </div>
       <div class="server-center">
         <div class="server-network-option">
-						<span id="open-network-settings">${t.__('Network and Proxy Settings')}</span>
+          <span id="open-network-settings"
+            >${t.__("Network and Proxy Settings")}</span
+          >
           <i class="material-icons open-network-button">open_in_new</i>
         </div>
       </div>
     </div>
-		`;
+  `);
-	}
+  const $saveServerButton: HTMLButtonElement =
+    $newServerForm.querySelector("#connect")!;
+  $root.textContent = "";
+  $root.append($newServerForm);
+  const $newServerUrl: HTMLInputElement = $newServerForm.querySelector(
+    "input.setting-input-value",
+  )!;
 
-	init(): void {
+  async function submitFormHandler(): Promise<void> {
-		this.initForm();
+    $saveServerButton.textContent = "Connecting...";
-		this.initActions();
-	}
-
-	initForm(): void {
-		this.$newServerForm = this.generateNodeFromTemplate(this.template());
-		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;
-	}
-
-	async submitFormHandler(): Promise<void> {
-		this.$saveServerButton.innerHTML = 'Connecting...';
     let serverConf;
     try {
-			serverConf = await DomainUtil.checkDomain(this.$newServerUrl.value);
+      serverConf = await DomainUtil.checkDomain($newServerUrl.value.trim());
-		} catch (errorMessage) {
+    } catch (error: unknown) {
-			this.$saveServerButton.innerHTML = 'Connect';
+      $saveServerButton.textContent = "Connect";
-			alert(errorMessage);
+      await dialog.showMessageBox({
+        type: "error",
+        message:
+          error instanceof Error
+            ? `${error.name}: ${error.message}`
+            : "Unknown error",
+        buttons: ["OK"],
+      });
       return;
     }
+
     await DomainUtil.addDomain(serverConf);
-		this.props.onChange();
+    onChange();
   }
 
-	openCreateNewOrgExternalLink(): void {
+  $saveServerButton.addEventListener("click", async () => {
-		const link = 'https://zulipchat.com/new/';
+    await submitFormHandler();
-		const externalCreateNewOrgElement = document.querySelector('#open-create-org-link');
-		externalCreateNewOrgElement.addEventListener('click', () => {
-			LinkUtil.openBrowser(new URL(link));
   });
+  $newServerUrl.addEventListener("keypress", async (event) => {
+    if (event.key === "Enter") {
+      await submitFormHandler();
     }
+  });
 
-	networkSettingsLink(): void {
+  // Open create new org link in default browser
-		const networkSettingsId = document.querySelectorAll('.server-network-option')[0];
+  const link = "https://zulip.com/new/";
-		networkSettingsId.addEventListener('click', () => ipcRenderer.send('forward-message', 'open-network-settings'));
+  const externalCreateNewOrgElement = $root.querySelector(
-	}
+    "#open-create-org-link",
+  )!;
+  externalCreateNewOrgElement.addEventListener("click", async () => {
+    await LinkUtil.openBrowser(new URL(link));
+  });
 
-	initActions(): void {
+  const networkSettingsId = $root.querySelector(".server-network-option")!;
-		this.$saveServerButton.addEventListener('click', () => {
+  networkSettingsId.addEventListener("click", () => {
-			this.submitFormHandler();
+    ipcRenderer.send("forward-message", "open-network-settings");
   });
-		this.$newServerUrl.addEventListener('keypress', event => {
-			if (event.key === 'Enter') {
-				this.submitFormHandler();
-			}
-		});
-		// open create new org link in default browser
-		this.openCreateNewOrgExternalLink();
-		this.networkSettingsLink();
-	}
 }

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

@@ -1,122 +1,146 @@
-import { ipcRenderer } from 'electron';
+import process from "node:process";
 
-import BaseComponent from '../../components/base';
+import type {DndSettings} from "../../../../common/dnd-util";
-import Nav from './nav';
+import {html} from "../../../../common/html";
-import ServersSection from './servers-section';
+import type {NavItem} from "../../../../common/types";
-import GeneralSection from './general-section';
+import {ipcRenderer} from "../../typed-ipc-renderer";
-import NetworkSection from './network-section';
-import ConnectedOrgSection from './connected-org-section';
-import ShortcutsSection from './shortcuts-section';
 
-type Section = ServersSection | GeneralSection | NetworkSection | ConnectedOrgSection | ShortcutsSection;
+import {initConnectedOrgSection} from "./connected-org-section";
+import {initGeneralSection} from "./general-section";
+import Nav from "./nav";
+import {initNetworkSection} from "./network-section";
+import {initServersSection} from "./servers-section";
+import {initShortcutsSection} from "./shortcuts-section";
+
+export class PreferenceView {
+  readonly $view: HTMLElement;
+  private readonly $shadow: ShadowRoot;
+  private readonly $settingsContainer: Element;
+  private readonly nav: Nav;
+  private navItem: NavItem = "General";
 
-export default class PreferenceView extends BaseComponent {
-	$sidebarContainer: Element;
-	$settingsContainer: Element;
-	nav: Nav;
-	section: Section;
   constructor() {
-		super();
+    this.$view = document.createElement("div");
-		this.$sidebarContainer = document.querySelector('#sidebar');
+    this.$shadow = this.$view.attachShadow({mode: "open"});
-		this.$settingsContainer = document.querySelector('#settings-container');
+    this.$shadow.innerHTML = html`
-	}
+      <link
+        rel="stylesheet"
+        href="${require.resolve("../../../css/fonts.css")}"
+      />
+      <link
+        rel="stylesheet"
+        href="${require.resolve("../../../css/preference.css")}"
+      />
+      <link
+        rel="stylesheet"
+        href="${require.resolve("@yaireo/tagify/dist/tagify.css")}"
+      />
+      <!-- Initially hidden to prevent FOUC -->
+      <div id="content" hidden>
+        <div id="sidebar"></div>
+        <div id="settings-container"></div>
+      </div>
+    `.html;
+
+    const $sidebarContainer = this.$shadow.querySelector("#sidebar")!;
+    this.$settingsContainer = this.$shadow.querySelector(
+      "#settings-container",
+    )!;
 
-	init(): void {
     this.nav = new Nav({
-			$root: this.$sidebarContainer,
+      $root: $sidebarContainer,
-			onItemSelected: this.handleNavigation.bind(this)
+      onItemSelected: this.handleNavigation,
     });
 
-		this.setDefaultView();
+    ipcRenderer.on("toggle-sidebar", this.handleToggleSidebar);
-		this.registerIpcs();
+    ipcRenderer.on("toggle-autohide-menubar", this.handleToggleMenubar);
+    ipcRenderer.on("toggle-dnd", this.handleToggleDnd);
+
+    this.handleNavigation(this.navItem);
   }
 
-	setDefaultView(): void {
+  handleNavigation = (navItem: NavItem): void => {
-		let nav = 'General';
+    this.navItem = navItem;
-		const hasTag = window.location.hash;
-		if (hasTag) {
-			nav = hasTag.slice(1);
-		}
-		this.handleNavigation(nav);
-	}
-
-	handleNavigation(navItem: string): void {
     this.nav.select(navItem);
     switch (navItem) {
-			case 'AddServer': {
+      case "AddServer":
-				this.section = new ServersSection({
+        initServersSection({
-					$root: this.$settingsContainer
+          $root: this.$settingsContainer,
+        });
+        break;
+
+      case "General":
+        initGeneralSection({
+          $root: this.$settingsContainer,
+        });
+        break;
+
+      case "Organizations":
+        initConnectedOrgSection({
+          $root: this.$settingsContainer,
+        });
+        break;
+
+      case "Network":
+        initNetworkSection({
+          $root: this.$settingsContainer,
+        });
+        break;
+
+      case "Shortcuts": {
+        initShortcutsSection({
+          $root: this.$settingsContainer,
         });
         break;
       }
-			case 'General': {
+
-				this.section = new GeneralSection({
+      default:
-					$root: this.$settingsContainer
+        ((n: never) => n)(navItem);
-				});
-				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}`;
+  };
+
+  handleToggleTray(state: boolean) {
+    this.handleToggle("tray-option", state);
+  }
+
+  destroy(): void {
+    ipcRenderer.off("toggle-sidebar", this.handleToggleSidebar);
+    ipcRenderer.off("toggle-autohide-menubar", this.handleToggleMenubar);
+    ipcRenderer.off("toggle-dnd", this.handleToggleDnd);
   }
 
   // Handle toggling and reflect changes in preference page
-	handleToggle(elementName: string, state: boolean): void {
+  private handleToggle(elementName: string, state = false): void {
     const inputSelector = `#${elementName} .action .switch input`;
-		const input: HTMLInputElement = document.querySelector(inputSelector);
+    const input: HTMLInputElement = this.$shadow.querySelector(inputSelector)!;
     if (input) {
       input.checked = state;
     }
   }
 
-	registerIpcs(): void {
+  private readonly handleToggleSidebar = (_event: Event, state: boolean) => {
-		ipcRenderer.on('switch-settings-nav', (_event: Event, navItem: string) => {
+    this.handleToggle("sidebar-option", state);
-			this.handleNavigation(navItem);
+  };
-		});
 
-		ipcRenderer.on('toggle-sidebar-setting', (_event: Event, state: boolean) => {
+  private readonly handleToggleMenubar = (_event: Event, state: boolean) => {
-			this.handleToggle('sidebar-option', state);
+    this.handleToggle("menubar-option", state);
-		});
+  };
 
-		ipcRenderer.on('toggle-menubar-setting', (_event: Event, state: boolean) => {
+  private readonly handleToggleDnd = (
-			this.handleToggle('menubar-option', state);
+    _event: Event,
-		});
+    _state: boolean,
+    newSettings: Partial<DndSettings>,
+  ) => {
+    this.handleToggle("show-notification-option", newSettings.showNotification);
+    this.handleToggle("silent-option", newSettings.silent);
 
-		ipcRenderer.on('toggletray', (_event: Event, state: boolean) => {
+    if (process.platform === "win32") {
-			this.handleToggle('tray-option', state);
+      this.handleToggle(
-		});
+        "flash-taskbar-option",
-
+        newSettings.flashTaskbarOnMessage,
-		ipcRenderer.on('toggle-dnd', (_event: Event, _state: boolean, newSettings: any) => {
+      );
-			this.handleToggle('show-notification-option', newSettings.showNotification);
-			this.handleToggle('silent-option', newSettings.silent);
-
-			if (process.platform === 'win32') {
-				this.handleToggle('flash-taskbar-option', newSettings.flashTaskbarOnMessage);
-			}
-		});
     }
+  };
 }
-
-window.addEventListener('load', () => {
-	const preferenceView = new PreferenceView();
-	preferenceView.init();
-});

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

@@ -1,97 +1,80 @@
-import { remote, ipcRenderer } from 'electron';
+import {dialog} from "@electron/remote";
 
-import BaseComponent from '../../components/base';
+import {html} from "../../../../common/html";
-import * as DomainUtil from '../../utils/domain-util';
+import * as Messages from "../../../../common/messages";
-import * as Messages from '../../../../resources/messages';
+import * as t from "../../../../common/translation-util";
-import * as t from '../../utils/translation-util';
+import type {ServerConf} from "../../../../common/types";
-
+import {generateNodeFromHtml} from "../../components/base";
-const { dialog } = remote;
+import {ipcRenderer} from "../../typed-ipc-renderer";
+import * as DomainUtil from "../../utils/domain-util";
 
 interface ServerInfoFormProps {
   $root: Element;
-	server: DomainUtil.ServerConf;
+  server: ServerConf;
   index: number;
   onChange: () => void;
 }
 
-export default class ServerInfoForm extends BaseComponent {
+export function initServerInfoForm(props: ServerInfoFormProps): void {
-	props: ServerInfoFormProps;
+  const $serverInfoForm = generateNodeFromHtml(html`
-	$serverInfoForm: Element;
-	$serverInfoAlias: Element;
-	$serverIcon: Element;
-	$deleteServerButton: Element;
-	$openServerButton: Element;
-	constructor(props: ServerInfoFormProps) {
-		super();
-		this.props = props;
-	}
-
-	template(): string {
-		return `
     <div class="settings-card">
       <div class="server-info-left">
-					<img class="server-info-icon" src="${this.props.server.icon}"/>
+        <img class="server-info-icon" src="${props.server.icon}" />
         <div class="server-info-row">
-						<span class="server-info-alias">${this.props.server.alias}</span>
+          <span class="server-info-alias">${props.server.alias}</span>
           <i class="material-icons open-tab-button">open_in_new</i>
         </div>
       </div>
       <div class="server-info-right">
         <div class="server-info-row server-url">
-						<span class="server-url-info" title="${this.props.server.url}">${this.props.server.url}</span>
+          <span class="server-url-info" title="${props.server.url}"
+            >${props.server.url}</span
+          >
         </div>
         <div class="server-info-row">
           <div class="action red server-delete-action">
-							<span>${t.__('Disconnect')}</span>
+            <span>${t.__("Disconnect")}</span>
           </div>
         </div>
       </div>
     </div>
-		`;
+  `);
-	}
+  const $serverInfoAlias = $serverInfoForm.querySelector(".server-info-alias")!;
+  const $serverIcon = $serverInfoForm.querySelector(".server-info-icon")!;
+  const $deleteServerButton = $serverInfoForm.querySelector(
+    ".server-delete-action",
+  )!;
+  const $openServerButton = $serverInfoForm.querySelector(".open-tab-button")!;
+  props.$root.append($serverInfoForm);
 
-	init(): void {
+  $deleteServerButton.addEventListener("click", async () => {
-		this.initForm();
+    const {response} = await dialog.showMessageBox({
-		this.initActions();
+      type: "warning",
-	}
+      buttons: [t.__("YES"), t.__("NO")],
-
-	initForm(): void {
-		this.$serverInfoForm = this.generateNodeFromTemplate(this.template());
-		this.$serverInfoAlias = this.$serverInfoForm.querySelectorAll('.server-info-alias')[0];
-		this.$serverIcon = this.$serverInfoForm.querySelectorAll('.server-info-icon')[0];
-		this.$deleteServerButton = this.$serverInfoForm.querySelectorAll('.server-delete-action')[0];
-		this.$openServerButton = this.$serverInfoForm.querySelectorAll('.open-tab-button')[0];
-		this.props.$root.append(this.$serverInfoForm);
-	}
-
-	initActions(): void {
-		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?')
+      message: t.__("Are you sure you want to disconnect this organization?"),
     });
     if (response === 0) {
-				if (DomainUtil.removeDomain(this.props.index)) {
+      if (DomainUtil.removeDomain(props.index)) {
-					ipcRenderer.send('reload-full-app');
+        ipcRenderer.send("reload-full-app");
       } else {
-					const { title, content } = Messages.orgRemovalError(DomainUtil.getDomain(this.props.index).url);
+        const {title, content} = Messages.orgRemovalError(
+          DomainUtil.getDomain(props.index).url,
+        );
         dialog.showErrorBox(title, content);
       }
     }
   });
 
-		this.$openServerButton.addEventListener('click', () => {
+  $openServerButton.addEventListener("click", () => {
-			ipcRenderer.send('forward-message', 'switch-server-tab', this.props.index);
+    ipcRenderer.send("forward-message", "switch-server-tab", props.index);
   });
 
-		this.$serverInfoAlias.addEventListener('click', () => {
+  $serverInfoAlias.addEventListener("click", () => {
-			ipcRenderer.send('forward-message', 'switch-server-tab', this.props.index);
+    ipcRenderer.send("forward-message", "switch-server-tab", props.index);
   });
 
-		this.$serverIcon.addEventListener('click', () => {
+  $serverIcon.addEventListener("click", () => {
-			ipcRenderer.send('forward-message', 'switch-server-tab', this.props.index);
+    ipcRenderer.send("forward-message", "switch-server-tab", props.index);
   });
-	}
 }

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

@@ -1,49 +1,28 @@
-import BaseSection from './base-section';
+import {html} from "../../../../common/html";
-import NewServerForm from './new-server-form';
+import * as t from "../../../../common/translation-util";
-import * as t from '../../utils/translation-util';
+
+import {reloadApp} from "./base-section";
+import {initNewServerForm} from "./new-server-form";
 
 interface ServersSectionProps {
   $root: Element;
 }
 
-export default class ServersSection extends BaseSection {
+export function initServersSection({$root}: ServersSectionProps): void {
-	props: ServersSectionProps;
+  $root.innerHTML = html`
-	$newServerContainer: Element;
-	constructor(props: ServersSectionProps) {
-		super();
-		this.props = props;
-	}
-
-	template(): string {
-		return `
     <div class="add-server-modal">
       <div class="modal-container">
         <div class="settings-pane" id="server-settings-pane">
-					<div class="page-title">${t.__('Add a Zulip organization')}</div>
+          <div class="page-title">${t.__("Add a Zulip organization")}</div>
           <div id="new-server-container"></div>
         </div>
       </div>
     </div>
-		`;
+  `.html;
-	}
+  const $newServerContainer = $root.querySelector("#new-server-container")!;
 
-	init(): void {
+  initNewServerForm({
-		this.initServers();
+    $root: $newServerContainer,
-	}
+    onChange: reloadApp,
-
+  });
-	initServers(): void {
-		this.props.$root.innerHTML = '';
-
-		this.props.$root.innerHTML = this.template();
-		this.$newServerContainer = document.querySelector('#new-server-container');
-
-		this.initNewServerForm();
-	}
-
-	initNewServerForm(): void {
-		new NewServerForm({
-			$root: this.$newServerContainer,
-			onChange: this.reloadApp
-		}).init();
-	}
 }

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

@@ -1,345 +1,233 @@
-import BaseSection from './base-section';
+import process from "node:process";
-import * as LinkUtil from '../../utils/link-util';
+
-import * as t from '../../utils/translation-util';
+import {html} from "../../../../common/html";
+import * as LinkUtil from "../../../../common/link-util";
+import * as t from "../../../../common/translation-util";
 
 interface ShortcutsSectionProps {
   $root: Element;
 }
 
-export default class ShortcutsSection extends BaseSection {
+// eslint-disable-next-line complexity
-	props: ShortcutsSectionProps;
+export function initShortcutsSection({$root}: ShortcutsSectionProps): void {
-	constructor(props: ShortcutsSectionProps) {
+  const cmdOrCtrl = process.platform === "darwin" ? "⌘" : "Ctrl";
-		super();
-		this.props = props;
-	}
 
-	// TODO - Deduplicate templateMac and templateWinLin functions. In theory
+  $root.innerHTML = html`
-	// 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
-	// lines though one may just be using more new lines and other thing is the use of +.
-	templateMac(): string {
-		const userOSKey = '⌘';
-
-		return `
     <div class="settings-pane">
-						<div class="settings-card tip"><p><b><i class="material-icons md-14">settings</i>${t.__('Tip')}:  </b>${t.__('These desktop app shortcuts extend the Zulip webapp\'s')} <span id="open-hotkeys-link"> ${t.__('keyboard shortcuts')}</span>.</p></div>
+      <div class="settings-card tip">
-							<div class="title">${t.__('Application Shortcuts')}</div>
+        <p>
+          <b><i class="material-icons md-14">settings</i>${t.__("Tip")}: </b
+          >${t.__("These desktop app shortcuts extend the Zulip webapp's")}
+          <span id="open-hotkeys-link"> ${t.__("keyboard shortcuts")}</span>.
+        </p>
+      </div>
+      <div class="title">${t.__("Application Shortcuts")}</div>
       <div class="settings-card">
         <table>
           <tr>
-										<td><kbd>${userOSKey}</kbd><kbd>,</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>,</kbd></td>
-										<td>${t.__('Settings')}</td>
+            <td>${t.__("Settings")}</td>
           </tr>
           <tr>
-										<td><kbd>${userOSKey}</kbd><kbd>K</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>K</kbd></td>
-										<td>${t.__('Keyboard Shortcuts')}</td>
+            <td>${t.__("Keyboard Shortcuts")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Shift</kbd> + <kbd>M</kbd></td>
+            <td>${t.__("Toggle Do Not Disturb")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>Shift</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>M</kbd></td>
+            <td>${t.__("Toggle Do Not Disturb")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>Shift</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>D</kbd></td>
+            <td>${t.__("Reset App Settings")}</td>
           </tr>
           <tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>M</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>L</kbd></td>
-										<td>${t.__('Toggle Do Not Disturb')}</td>
+            <td>${t.__("Log Out")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>H</kbd></td>
+            <td>${t.__("Hide Zulip")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>Option</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>H</kbd></td>
+            <td>${t.__("Hide Others")}</td>
           </tr>
           <tr>
-										<td><kbd>Shift</kbd><kbd>${userOSKey}</kbd><kbd>D</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Q</kbd></td>
-										<td>${t.__('Reset App Settings')}</td>
+            <td>${t.__("Quit Zulip")}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd><kbd>L</kbd></td>
-										<td>${t.__('Log Out')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd><kbd>H</kbd></td>
-										<td>${t.__('Hide Zulip')}</td>
-									</tr>
-									<tr>
-										<td><kbd>Option</kbd><kbd>${userOSKey}</kbd><kbd>H</kbd></td>
-										<td>${t.__('Hide Others')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd><kbd>Q</kbd></td>
-										<td>${t.__('Quit Zulip')}</td>
           </tr>
         </table>
         <div class="setting-control"></div>
       </div>
-							<div class="title">${t.__('Edit Shortcuts')}</div>
+      <div class="title">${t.__("Edit Shortcuts")}</div>
       <div class="settings-card">
         <table>
           <tr>
-										<td><kbd>${userOSKey}</kbd><kbd>Z</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Z</kbd></td>
-										<td>${t.__('Undo')}</td>
+            <td>${t.__("Undo")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>Shift</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>Z</kbd></td>
+            <td>${t.__("Redo")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Y</kbd></td>
+            <td>${t.__("Redo")}</td>
           </tr>
           <tr>
-										<td><kbd>Shift</kbd><kbd>${userOSKey}</kbd><kbd>Z</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>X</kbd></td>
-										<td>${t.__('Redo')}</td>
+            <td>${t.__("Cut")}</td>
           </tr>
           <tr>
-										<td><kbd>${userOSKey}</kbd><kbd>X</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>C</kbd></td>
-										<td>${t.__('Cut')}</td>
+            <td>${t.__("Copy")}</td>
           </tr>
           <tr>
-										<td><kbd>${userOSKey}</kbd><kbd>C</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>V</kbd></td>
-										<td>${t.__('Copy')}</td>
+            <td>${t.__("Paste")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Shift</kbd> + <kbd>V</kbd></td>
+            <td>${t.__("Paste and Match Style")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>Shift</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>V</kbd></td>
+            <td>${t.__("Paste and Match Style")}</td>
           </tr>
           <tr>
-										<td><kbd>${userOSKey}</kbd><kbd>V</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>A</kbd></td>
-										<td>${t.__('Paste')}</td>
+            <td>${t.__("Select All")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
-										<td><kbd>Shift</kbd><kbd>${userOSKey}</kbd><kbd>V</kbd></td>
+            <td>
-										<td>${t.__('Paste and Match Style')}</td>
+              <kbd>Control</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>Space</kbd>
-									</tr>
+            </td>
-									<tr>
+            <td>${t.__("Emoji & Symbols")}</td>
-										<td><kbd>${userOSKey}</kbd><kbd>A</kbd></td>
-										<td>${t.__('Select All')}</td>
-									</tr>
-									<tr>
-										<td><kbd>Control</kbd><kbd>${userOSKey}</kbd><kbd>Space</kbd></td>
-										<td>${t.__('Emoji & Symbols')}</td>
           </tr>
         </table>
         <div class="setting-control"></div>
       </div>
-							<div class="title">${t.__('View Shortcuts')}</div>
+      <div class="title">${t.__("View Shortcuts")}</div>
       <div class="settings-card">
         <table>
           <tr>
-										<td><kbd>${userOSKey}</kbd><kbd>R</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>R</kbd></td>
-										<td>${t.__('Reload')}</td>
+            <td>${t.__("Reload")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Shift</kbd> + <kbd>R</kbd></td>
+            <td>${t.__("Hard Reload")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>Shift</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>R</kbd></td>
+            <td>${t.__("Hard Reload")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
+            <td><kbd>F11</kbd></td>
+            <td>${t.__("Toggle Full Screen")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>Control</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>F</kbd></td>
+            <td>${t.__("Enter Full Screen")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>+</kbd></td>
+            <td>${t.__("Zoom In")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>=</kbd></td>
+            <td>${t.__("Zoom In")}</td>
           </tr>
           <tr>
-										<td><kbd>Shift</kbd><kbd>${userOSKey}</kbd><kbd>R</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>-</kbd></td>
-										<td>${t.__('Hard Reload')}</td>
+            <td>${t.__("Zoom Out")}</td>
           </tr>
           <tr>
-										<td><kbd>Control</kbd><kbd>${userOSKey}</kbd><kbd>F</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>0</kbd></td>
-										<td>${t.__('Enter Full Screen')}</td>
+            <td>${t.__("Actual Size")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
-										<td><kbd>${userOSKey}</kbd><kbd>+</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Shift</kbd> + <kbd>S</kbd></td>
-										<td>${t.__('Zoom In')}</td>
+            <td>${t.__("Toggle Sidebar")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
-										<td><kbd>${userOSKey}</kbd><kbd>-</kbd></td>
+            <td><kbd>Shift</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>S</kbd></td>
-										<td>${t.__('Zoom Out')}</td>
+            <td>${t.__("Toggle Sidebar")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
-										<td><kbd>${userOSKey}</kbd><kbd>0</kbd></td>
+            <td><kbd>Option</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>I</kbd></td>
-										<td>${t.__('Actual Size')}</td>
+            <td>${t.__("Toggle DevTools for Zulip App")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>S</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Shift</kbd> + <kbd>I</kbd></td>
-										<td>${t.__('Toggle Sidebar')}</td>
+            <td>${t.__("Toggle DevTools for Zulip App")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
-										<td><kbd>Option</kbd><kbd>${userOSKey}</kbd><kbd>I</kbd></td>
+            <td><kbd>Option</kbd> + <kbd>${cmdOrCtrl}</kbd> + <kbd>U</kbd></td>
-										<td>${t.__('Toggle DevTools for Zulip App')}</td>
+            <td>${t.__("Toggle DevTools for Active Tab")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
-										<td><kbd>Option</kbd><kbd>${userOSKey}</kbd><kbd>U</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>Shift</kbd> + <kbd>U</kbd></td>
-										<td>${t.__('Toggle DevTools for Active Tab')}</td>
+            <td>${t.__("Toggle DevTools for Active Tab")}</td>
           </tr>
           <tr>
             <td><kbd>Ctrl</kbd> + <kbd>Tab</kbd></td>
-										<td>${t.__('Switch to Next Organization')}</td>
+            <td>${t.__("Switch to Next Organization")}</td>
           </tr>
           <tr>
             <td><kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Tab</kbd></td>
-										<td>${t.__('Switch to Previous Organization')}</td>
+            <td>${t.__("Switch to Previous Organization")}</td>
           </tr>
         </table>
         <div class="setting-control"></div>
       </div>
-							<div class="title">${t.__('History Shortcuts')}</div>
+      <div class="title">${t.__("History Shortcuts")}</div>
       <div class="settings-card">
         <table>
-									<tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
-										<td><kbd>${userOSKey}</kbd><kbd>←</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>←</kbd></td>
-										<td>${t.__('Back')}</td>
+            <td>${t.__("Back")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
-										<td><kbd>${userOSKey}</kbd><kbd>→</kbd></td>
-										<td>${t.__('Forward')}</td>
-									</tr>
-								</table>
-								<div class="setting-control"></div>
-							</div>
-							<div class="title">Window Shortcuts</div>
-							<div class="settings-card">
-								<table>
-									<tr>
-										<td><kbd>${userOSKey}</kbd><kbd>M</kbd></td>
-										<td>${t.__('Minimize')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd><kbd>W</kbd></td>
-										<td>${t.__('Close')}</td>
-									</tr>
-								</table>
-								<div class="setting-control"></div>
-							</div>
-						</div>
-		`;
-	}
-
-	templateWinLin(): string {
-		const userOSKey = 'Ctrl';
-
-		return `
-						<div class="settings-pane">
-						<div class="settings-card tip"><p><b><i class="material-icons md-14">settings</i>${t.__('Tip')}:  </b>${t.__('These desktop app shortcuts extend the Zulip webapp\'s')} <span id="open-hotkeys-link"> ${t.__('keyboard shortcuts')}</span>.</p></div>
-							<div class="title">${t.__('Application Shortcuts')}</div>
-							<div class="settings-card">
-								<table>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>,</kbd></td>
-										<td>${t.__('Settings')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>K</kbd></td>
-										<td>${t.__('Keyboard Shortcuts')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>M</kbd></td>
-										<td>${t.__('Toggle Do Not Disturb')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>L</kbd></td>
-										<td>${t.__('Log Out')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Q</kbd></td>
-										<td>${t.__('Quit Zulip')}</td>
-									</tr>
-								</table>
-								<div class="setting-control"></div>
-							</div>
-							<div class="title">${t.__('Edit Shortcuts')}</div>
-							<div class="settings-card">
-								<table>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Z</kbd></td>
-										<td>${t.__('Undo')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Y</kbd></td>
-										<td>${t.__('Redo')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>X</kbd></td>
-										<td>${t.__('Cut')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>C</kbd></td>
-										<td>${t.__('Copy')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>V</kbd></td>
-										<td>${t.__('Paste')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>V</kbd></td>
-										<td>${t.__('Paste and Match Style')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>A</kbd></td>
-										<td>${t.__('Select All')}</td>
-									</tr>
-								</table>
-								<div class="setting-control"></div>
-							</div>
-							<div class="title">${t.__('View Shortcuts')}</div>
-							<div class="settings-card">
-								<table>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>R</kbd></td>
-										<td>${t.__('Reload')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>R</kbd></td>
-										<td>${t.__('Hard Reload')}</td>
-									</tr>
-									<tr>
-										<td><kbd>F11</kbd></td>
-										<td>${t.__('Toggle Full Screen')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>=</kbd></td>
-										<td>${t.__('Zoom In')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>-</kbd></td>
-										<td>${t.__('Zoom Out')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>0</kbd></td>
-										<td>${t.__('Actual Size')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>S</kbd></td>
-										<td>${t.__('Toggle Sidebar')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>I</kbd></td>
-										<td>${t.__('Toggle DevTools for Zulip App')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>U</kbd></td>
-										<td>${t.__('Toggle DevTools for Active Tab')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Tab</kbd></td>
-										<td>${t.__('Switch to Next Organization')}</td>
-									</tr>
-									<tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>Shift</kbd> + <kbd>Tab</kbd></td>
-										<td>${t.__('Switch to Previous Organization')}</td>
-									</tr>
-								</table>
-								<div class="setting-control"></div>
-							</div>
-							<div class="title">${t.__('History Shortcuts')}</div>
-							<div class="settings-card">
-								<table>
-									<tr>
             <td><kbd>Alt</kbd> + <kbd>←</kbd></td>
-										<td>${t.__('Back')}</td>
+            <td>${t.__("Back")}</td>
           </tr>
-									<tr>
+          <tr ${process.platform === "darwin" ? "" : "hidden"}>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>→</kbd></td>
+            <td>${t.__("Forward")}</td>
+          </tr>
+          <tr ${process.platform === "darwin" ? "hidden" : ""}>
             <td><kbd>Alt</kbd> + <kbd>→</kbd></td>
-										<td>${t.__('Forward')}</td>
+            <td>${t.__("Forward")}</td>
           </tr>
         </table>
         <div class="setting-control"></div>
       </div>
-							<div class="title">${t.__('Window Shortcuts')}</div>
+      <div class="title">${t.__("Window Shortcuts")}</div>
       <div class="settings-card">
         <table>
           <tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>M</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>M</kbd></td>
-										<td>${t.__('Minimize')}</td>
+            <td>${t.__("Minimize")}</td>
           </tr>
           <tr>
-										<td><kbd>${userOSKey}</kbd> + <kbd>W</kbd></td>
+            <td><kbd>${cmdOrCtrl}</kbd> + <kbd>W</kbd></td>
-										<td>${t.__('Close')}</td>
+            <td>${t.__("Close")}</td>
           </tr>
         </table>
         <div class="setting-control"></div>
       </div>
     </div>
-		`;
+  `.html;
-	}
 
-	openHotkeysExternalLink(): void {
+  const link = "https://zulip.com/help/keyboard-shortcuts";
-		const link = 'https://zulipchat.com/help/keyboard-shortcuts';
+  const externalCreateNewOrgElement =
-		const externalCreateNewOrgElement = document.querySelector('#open-hotkeys-link');
+    $root.querySelector("#open-hotkeys-link")!;
-		externalCreateNewOrgElement.addEventListener('click', () => {
+  externalCreateNewOrgElement.addEventListener("click", async () => {
-			LinkUtil.openBrowser(new URL(link));
+    await LinkUtil.openBrowser(new URL(link));
   });
-	}
-
-	init(): void {
-		this.props.$root.innerHTML = (process.platform === 'darwin') ?
-			this.templateMac() : this.templateWinLin();
-		this.openHotkeysExternalLink();
-	}
 }

app/renderer/js/preload.ts

@@ -1,122 +1,81 @@
-import { contextBridge, ipcRenderer, webFrame } from 'electron';
+import {contextBridge, webFrame} from "electron/renderer";
-import fs from 'fs';
+import fs from "node:fs";
-import * as SetupSpellChecker from './spellchecker';
 
-import isDev from 'electron-is-dev';
+import electron_bridge, {bridgeEvents} from "./electron-bridge";
+import * as NetworkError from "./pages/network";
+import {ipcRenderer} from "./typed-ipc-renderer";
 
-import * as NetworkError from './pages/network';
+contextBridge.exposeInMainWorld("raw_electron_bridge", electron_bridge);
 
-// eslint-disable-next-line import/no-unassigned-import
+ipcRenderer.on("logout", () => {
-import './notification';
+  if (bridgeEvents.emit("logout")) {
+    return;
+  }
 
-// Prevent drag and drop event in main process which prevents remote code executaion
-// eslint-disable-next-line import/no-unassigned-import
-import './shared/preventdrag';
-
-import electron_bridge from './electron-bridge';
-contextBridge.exposeInMainWorld('raw_electron_bridge', electron_bridge);
-
-ipcRenderer.on('logout', () => {
   // Create the menu for the below
-	const dropdown: HTMLElement = document.querySelector('.dropdown-toggle');
+  const dropdown: HTMLElement = document.querySelector(".dropdown-toggle")!;
   dropdown.click();
 
-	const nodes: NodeListOf<HTMLElement> = document.querySelectorAll('.dropdown-menu li:last-child a');
+  const nodes: NodeListOf<HTMLElement> = document.querySelectorAll(
+    ".dropdown-menu li:last-child a",
+  );
   nodes[nodes.length - 1].click();
 });
 
-ipcRenderer.on('shortcut', () => {
+ipcRenderer.on("show-keyboard-shortcuts", () => {
+  if (bridgeEvents.emit("show-keyboard-shortcuts")) {
+    return;
+  }
+
   // Create the menu for the below
-	const node: HTMLElement = document.querySelector('a[data-overlay-trigger=keyboard-shortcuts]');
+  const node: HTMLElement = document.querySelector(
+    "a[data-overlay-trigger=keyboard-shortcuts]",
+  )!;
   // Additional check
-	if (node.textContent.trim().toLowerCase() === 'keyboard shortcuts (?)') {
+  if (node.textContent!.trim().toLowerCase() === "keyboard shortcuts (?)") {
     node.click();
   } else {
     // Atleast click the dropdown
-		const dropdown: HTMLElement = document.querySelector('.dropdown-toggle');
+    const dropdown: HTMLElement = document.querySelector(".dropdown-toggle")!;
     dropdown.click();
   }
 });
 
-ipcRenderer.on('show-notification-settings', () => {
+ipcRenderer.on("show-notification-settings", () => {
+  if (bridgeEvents.emit("show-notification-settings")) {
+    return;
+  }
+
   // Create the menu for the below
-	const dropdown: HTMLElement = document.querySelector('.dropdown-toggle');
+  const dropdown: HTMLElement = document.querySelector(".dropdown-toggle")!;
   dropdown.click();
 
-	const nodes: NodeListOf<HTMLElement> = document.querySelectorAll('.dropdown-menu li a');
+  const nodes: NodeListOf<HTMLElement> = document.querySelectorAll(
+    ".dropdown-menu li a",
+  );
   nodes[2].click();
 
-	const notificationItem: NodeListOf<HTMLElement> = document.querySelectorAll('.normal-settings-list li div');
+  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);
 });
 
-electron_bridge.once('zulip-loaded', ({ serverLanguage }) => {
+window.addEventListener("load", () => {
-	// Get the default language of the server
+  if (!location.href.includes("app/renderer/network.html")) {
-	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');
-		});
-	}
-});
-
-// Clean up spellchecker events after you navigate away from this page;
-// otherwise, you may experience errors
-window.addEventListener('beforeunload', (): void => {
-	SetupSpellChecker.unsubscribeSpellChecker();
-});
-
-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');
+  const $reconnectButton = document.querySelector("#reconnect")!;
+  const $settingsButton = document.querySelector("#settings")!;
   NetworkError.init($reconnectButton, $settingsButton);
 });
 
-// electron's globalShortcut can cause unexpected results
+(async () =>
-// so adding the reload shortcut in the old-school way
+  webFrame.executeJavaScript(
-// Zoom from numpad keys is not supported by electron, so adding it through listeners.
+    fs.readFileSync(require.resolve("./injected"), "utf8"),
-document.addEventListener('keydown', event => {
+  ))();
-	const cmdOrCtrl = event.ctrlKey || event.metaKey;
-	if (event.code === 'F5') {
-		ipcRenderer.send('forward-message', 'hard-reload');
-	} else if (cmdOrCtrl && (event.code === 'NumpadAdd' || event.code === 'Equal')) {
-		ipcRenderer.send('forward-message', 'zoomIn');
-	} else if (cmdOrCtrl && event.code === 'NumpadSubtract') {
-		ipcRenderer.send('forward-message', 'zoomOut');
-	} else if (cmdOrCtrl && event.code === 'Numpad0') {
-		ipcRenderer.send('forward-message', 'zoomActualSize');
-	}
-});
-
-// Set user as active and update the time of last activity
-ipcRenderer.on('set-active', () => {
-	if (isDev) {
-		console.log('active');
-	}
-	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
-ipcRenderer.on('set-idle', () => {
-	if (isDev) {
-		console.log('idle');
-	}
-	electron_bridge.idle_on_system = true;
-});
-
-webFrame.executeJavaScript(
-	fs.readFileSync(require.resolve('./injected'), 'utf8')
-);

app/renderer/js/shared/preventdrag.ts

@@ -1,17 +0,0 @@
-// 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
-// use drag and drop event to share files etc
-
-const preventDragAndDrop = (): void => {
-	const preventEvents = ['dragover', 'drop'];
-	preventEvents.forEach(dragEvents => {
-		document.addEventListener(dragEvents, event => {
-			event.preventDefault();
-		});
-	});
-};
-
-preventDragAndDrop();
-
-export {};

app/renderer/js/spellchecker.ts

@@ -1,59 +0,0 @@
-import type { Subject } from 'rxjs';
-import { SpellCheckHandler, ContextMenuListener, ContextMenuBuilder } from 'electron-spellchecker';
-
-import * as ConfigUtil from './utils/config-util';
-import Logger from './utils/logger-util';
-
-declare module 'electron-spellchecker' {
-	interface SpellCheckHandler {
-		currentSpellcheckerChanged: Subject<true>;
-		currentSpellcheckerLanguage: string;
-	}
-}
-
-const logger = new Logger({
-	file: 'errors.log',
-	timestamp: true
-});
-
-let spellCheckHandler: SpellCheckHandler;
-let contextMenuListener: ContextMenuListener;
-
-export function init(serverLanguage: string): void {
-	if (ConfigUtil.getConfigItem('enableSpellchecker')) {
-		enableSpellChecker();
-	}
-	enableContextMenu(serverLanguage);
-}
-
-function enableSpellChecker(): void {
-	try {
-		spellCheckHandler = new SpellCheckHandler();
-	} catch (err) {
-		logger.error(err);
-	}
-}
-
-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,39 +1,49 @@
-import { ipcRenderer, remote, WebviewTag, NativeImage } from 'electron';
+import type {NativeImage} from "electron/common";
+import {nativeImage} from "electron/common";
+import type {Tray as ElectronTray} from "electron/main";
+import path from "node:path";
+import process from "node:process";
 
-import path from 'path';
+import {BrowserWindow, Menu, Tray} from "@electron/remote";
-import * as ConfigUtil from './utils/config-util';
 
-const { Tray, Menu, nativeImage, BrowserWindow, nativeTheme } = remote;
+import * as ConfigUtil from "../../common/config-util";
+import type {RendererMessage} from "../../common/typed-ipc";
 
-let tray: Electron.Tray;
+import type {ServerManagerView} from "./main";
+import {ipcRenderer} from "./typed-ipc-renderer";
 
-// get the theme on macOS
+let tray: ElectronTray | null = null;
-const theme = nativeTheme.shouldUseDarkColors ? 'dark' : 'light';
 
-const ICON_DIR = process.platform === 'darwin' ? `../../resources/tray/${theme}` : '../../resources/tray';
+const iconDir = "../../resources/tray";
 
-const TRAY_SUFFIX = 'tray';
+const traySuffix = "tray";
 
-const APP_ICON = path.join(__dirname, ICON_DIR, TRAY_SUFFIX);
+const appIcon = path.join(__dirname, iconDir, traySuffix);
 
 const iconPath = (): string => {
-	if (process.platform === 'linux') {
+  if (process.platform === "linux") {
-		return APP_ICON + 'linux.png';
+    return appIcon + "linux.png";
   }
-	return APP_ICON + (process.platform === 'win32' ? 'win.ico' : 'osx.png');
+
+  return (
+    appIcon + (process.platform === "win32" ? "win.ico" : "macOSTemplate.png")
+  );
 };
 
+const winUnreadTrayIconPath = (): string => appIcon + "unread.ico";
+
 let unread = 0;
 
 const trayIconSize = (): number => {
   switch (process.platform) {
-		case 'darwin':
+    case "darwin":
       return 20;
-		case 'win32':
+    case "win32":
       return 100;
-		case 'linux':
+    case "linux":
       return 100;
-		default: return 80;
+    default:
+      return 80;
   }
 };
 
@@ -42,148 +52,160 @@ const config = {
   pixelRatio: window.devicePixelRatio,
   unreadCount: 0,
   showUnreadCount: true,
-	unreadColor: '#000000',
+  unreadColor: "#000000",
-	readColor: '#000000',
+  readColor: "#000000",
-	unreadBackgroundColor: '#B9FEEA',
+  unreadBackgroundColor: "#B9FEEA",
-	readBackgroundColor: '#B9FEEA',
+  readBackgroundColor: "#B9FEEA",
   size: trayIconSize(),
-	thick: process.platform === 'win32'
+  thick: process.platform === "win32",
 };
 
 const renderCanvas = function (arg: number): HTMLCanvasElement {
   config.unreadCount = arg;
 
-	const SIZE = config.size * config.pixelRatio;
+  const size = config.size * config.pixelRatio;
-	const PADDING = SIZE * 0.05;
+  const padding = size * 0.05;
-	const CENTER = SIZE / 2;
+  const center = size / 2;
-	const HAS_COUNT = config.showUnreadCount && config.unreadCount;
+  const hasCount = config.showUnreadCount && config.unreadCount;
   const color = config.unreadCount ? config.unreadColor : config.readColor;
-	const backgroundColor = config.unreadCount ? config.unreadBackgroundColor : config.readBackgroundColor;
+  const backgroundColor = config.unreadCount
+    ? config.unreadBackgroundColor
+    : config.readBackgroundColor;
 
-	const canvas = document.createElement('canvas');
+  const canvas = document.createElement("canvas");
-	canvas.width = SIZE;
+  canvas.width = size;
-	canvas.height = SIZE;
+  canvas.height = size;
-	const ctx = canvas.getContext('2d');
+  const ctx = canvas.getContext("2d")!;
 
   // Circle
-	// If (!config.thick || config.thick && HAS_COUNT) {
+  // If (!config.thick || config.thick && hasCount) {
   ctx.beginPath();
-	ctx.arc(CENTER, CENTER, (SIZE / 2) - PADDING, 0, 2 * Math.PI, false);
+  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.lineWidth = size / (config.thick ? 10 : 20);
   ctx.strokeStyle = backgroundColor;
   ctx.stroke();
   // Count or Icon
-	if (HAS_COUNT) {
+  if (hasCount) {
     ctx.fillStyle = color;
-		ctx.textAlign = 'center';
+    ctx.textAlign = "center";
     if (config.unreadCount > 99) {
-			ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.4}px Helvetica`;
+      ctx.font = `${config.thick ? "bold " : ""}${size * 0.4}px Helvetica`;
-			ctx.fillText('99+', CENTER, CENTER + (SIZE * 0.15));
+      ctx.fillText("99+", center, center + size * 0.15);
     } else if (config.unreadCount < 10) {
-			ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.5}px Helvetica`;
+      ctx.font = `${config.thick ? "bold " : ""}${size * 0.5}px Helvetica`;
-			ctx.fillText(String(config.unreadCount), CENTER, CENTER + (SIZE * 0.2));
+      ctx.fillText(String(config.unreadCount), center, center + size * 0.2);
     } else {
-			ctx.font = `${config.thick ? 'bold ' : ''}${SIZE * 0.5}px Helvetica`;
+      ctx.font = `${config.thick ? "bold " : ""}${size * 0.5}px Helvetica`;
-			ctx.fillText(String(config.unreadCount), CENTER, CENTER + (SIZE * 0.15));
+      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): NativeImage {
+  if (process.platform === "win32") {
+    return nativeImage.createFromPath(winUnreadTrayIconPath());
+  }
+
   const canvas = renderCanvas(arg);
-	const pngData = nativeImage.createFromDataURL(canvas.toDataURL('image/png')).toPNG();
+  const pngData = nativeImage
+    .createFromDataURL(canvas.toDataURL("image/png"))
+    .toPNG();
   return nativeImage.createFromBuffer(pngData, {
-		scaleFactor: config.pixelRatio
+    scaleFactor: config.pixelRatio,
   });
 };
 
-function sendAction(action: string): void {
+function sendAction<Channel extends keyof RendererMessage>(
+  channel: Channel,
+  ...args: Parameters<RendererMessage[Channel]>
+): void {
   const win = BrowserWindow.getAllWindows()[0];
 
-	if (process.platform === 'darwin') {
+  if (process.platform === "darwin") {
     win.restore();
   }
 
-	win.webContents.send(action);
+  ipcRenderer.sendTo(win.webContents.id, channel, ...args);
 }
 
 const createTray = function (): void {
   const contextMenu = Menu.buildFromTemplate([
     {
-			label: 'Zulip',
+      label: "Zulip",
       click() {
-				ipcRenderer.send('focus-app');
+        ipcRenderer.send("focus-app");
-			}
+      },
     },
     {
-			label: 'Settings',
+      label: "Settings",
       click() {
-				ipcRenderer.send('focus-app');
+        ipcRenderer.send("focus-app");
-				sendAction('open-settings');
+        sendAction("open-settings");
-			}
+      },
     },
     {
-			type: 'separator'
+      type: "separator",
     },
     {
-			label: 'Quit',
+      label: "Quit",
       click() {
-				ipcRenderer.send('quit-app');
+        ipcRenderer.send("quit-app");
-			}
+      },
-		}
+    },
   ]);
   tray = new Tray(iconPath());
   tray.setContextMenu(contextMenu);
-	if (process.platform === 'linux' || process.platform === 'win32') {
+  if (process.platform === "linux" || process.platform === "win32") {
-		tray.on('click', () => {
+    tray.on("click", () => {
-			ipcRenderer.send('toggle-app');
+      ipcRenderer.send("toggle-app");
     });
   }
 };
 
-ipcRenderer.on('destroytray', (event: Event): Event => {
+export function initializeTray(serverManagerView: ServerManagerView) {
+  ipcRenderer.on("destroytray", (_event: Event) => {
     if (!tray) {
-		return undefined;
+      return;
     }
 
     tray.destroy();
     if (tray.isDestroyed()) {
       tray = null;
     } else {
-		throw new Error('Tray icon not properly destroyed.');
+      throw new Error("Tray icon not properly destroyed.");
     }
+  });
 
-	return event;
+  ipcRenderer.on("tray", (_event: Event, arg: number): void => {
-});
-
-ipcRenderer.on('tray', (_event: Event, arg: number): void => {
     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 (process.platform === "linux" || process.platform === "win32") {
       if (arg === 0) {
         unread = arg;
         tray.setImage(iconPath());
-			tray.setToolTip('No unread messages');
+        tray.setToolTip("No unread messages");
       } else {
         unread = arg;
         const image = renderNativeImage(arg);
         tray.setImage(image);
-			tray.setToolTip(arg + ' unread messages');
+        tray.setToolTip(`${arg} unread messages`);
       }
     }
-});
+  });
 
-function toggleTray(): void {
+  function toggleTray(): void {
     let state;
     if (tray) {
       state = false;
@@ -191,27 +213,28 @@ function toggleTray(): void {
       if (tray.isDestroyed()) {
         tray = null;
       }
-		ConfigUtil.setConfigItem('trayIcon', false);
+
+      ConfigUtil.setConfigItem("trayIcon", false);
     } else {
       state = true;
       createTray();
-		if (process.platform === 'linux' || process.platform === 'win32') {
+      if (process.platform === "linux" || process.platform === "win32") {
         const image = renderNativeImage(unread);
-			tray.setImage(image);
+        tray!.setImage(image);
-			tray.setToolTip(unread + ' unread messages');
+        tray!.setToolTip(`${unread} unread messages`);
       }
-		ConfigUtil.setConfigItem('trayIcon', true);
+
+      ConfigUtil.setConfigItem("trayIcon", true);
     }
-	const selector = 'webview:not([class*=disabled])';
-	const webview: WebviewTag = document.querySelector(selector);
-	const webContents = webview.getWebContents();
-	webContents.send('toggletray', state);
-}
 
-ipcRenderer.on('toggletray', toggleTray);
+    serverManagerView.preferenceView?.handleToggleTray(state);
+  }
 
-if (ConfigUtil.getConfigItem('trayIcon', true)) {
+  ipcRenderer.on("toggletray", toggleTray);
+
+  if (ConfigUtil.getConfigItem("trayIcon", true)) {
     createTray();
+  }
 }
 
 export {};

app/renderer/js/typed-ipc-renderer.ts

@@ -0,0 +1,68 @@
+import type {IpcRendererEvent} from "electron/renderer";
+import {
+  ipcRenderer as untypedIpcRenderer, // eslint-disable-line no-restricted-imports
+} from "electron/renderer";
+
+import type {
+  MainCall,
+  MainMessage,
+  RendererMessage,
+} from "../../common/typed-ipc";
+
+type RendererListener<Channel extends keyof RendererMessage> =
+  RendererMessage[Channel] extends (...args: infer Args) => void
+    ? (event: IpcRendererEvent, ...args: Args) => void
+    : never;
+
+export const ipcRenderer: {
+  on<Channel extends keyof RendererMessage>(
+    channel: Channel,
+    listener: RendererListener<Channel>,
+  ): void;
+  once<Channel extends keyof RendererMessage>(
+    channel: Channel,
+    listener: RendererListener<Channel>,
+  ): void;
+  off<Channel extends keyof RendererMessage>(
+    channel: Channel,
+    listener: RendererListener<Channel>,
+  ): void;
+  removeListener<Channel extends keyof RendererMessage>(
+    channel: Channel,
+    listener: RendererListener<Channel>,
+  ): void;
+  removeAllListeners(channel: keyof RendererMessage): void;
+  send<Channel extends keyof RendererMessage>(
+    channel: "forward-message",
+    rendererChannel: Channel,
+    ...args: Parameters<RendererMessage[Channel]>
+  ): void;
+  send<Channel extends keyof MainMessage>(
+    channel: Channel,
+    ...args: Parameters<MainMessage[Channel]>
+  ): void;
+  invoke<Channel extends keyof MainCall>(
+    channel: Channel,
+    ...args: Parameters<MainCall[Channel]>
+  ): Promise<ReturnType<MainCall[Channel]>>;
+  sendSync<Channel extends keyof MainMessage>(
+    channel: Channel,
+    ...args: Parameters<MainMessage[Channel]>
+  ): ReturnType<MainMessage[Channel]>;
+  postMessage<Channel extends keyof MainMessage>(
+    channel: Channel,
+    message: Parameters<MainMessage[Channel]> extends [infer Message]
+      ? Message
+      : never,
+    transfer?: MessagePort[],
+  ): void;
+  sendTo<Channel extends keyof RendererMessage>(
+    webContentsId: number,
+    channel: Channel,
+    ...args: Parameters<RendererMessage[Channel]>
+  ): void;
+  sendToHost<Channel extends keyof RendererMessage>(
+    channel: Channel,
+    ...args: Parameters<RendererMessage[Channel]>
+  ): void;
+} = untypedIpcRenderer;

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

@@ -1,80 +0,0 @@
-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';
-
-const { app, dialog } = remote;
-
-initSetUp();
-
-const logger = new Logger({
-	file: 'certificate-util.log',
-	timestamp: true
-});
-
-const certificatesDir = `${app.getPath('userData')}/certificates`;
-
-let db: JsonDB;
-
-reloadDB();
-
-export function getCertificate(server: string, defaultValue: any = null): any {
-	reloadDB();
-	const value = db.getData('/')[server];
-	if (value === undefined) {
-		return defaultValue;
-	} else {
-		return value;
-	}
-}
-
-// 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 (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;
-}
-
-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 (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);
-		}
-	}
-	db = new JsonDB(settingsJsonPath, true, true);
-}

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

@@ -1,8 +0,0 @@
-// 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;
-}

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

@@ -1,91 +0,0 @@
-import { JsonDB } from 'node-json-db';
-
-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 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;
-	dialog = remote.dialog;
-	app = remote.app;
-} else {
-	dialog = electron.dialog;
-	app = electron.app;
-}
-
-let db: JsonDB;
-
-reloadDB();
-
-export function getConfigItem(key: string, defaultValue: any = null): any {
-	try {
-		db.reload();
-	} catch (err) {
-		logger.error('Error while reloading settings.json: ');
-		logger.error(err);
-	}
-	const value = db.getData('/')[key];
-	if (value === undefined) {
-		setConfigItem(key, defaultValue);
-		return defaultValue;
-	} else {
-		return value;
-	}
-}
-
-// This function returns whether a key exists in the configuration file (settings.json)
-export function isConfigItemExists(key: string): boolean {
-	try {
-		db.reload();
-	} catch (err) {
-		logger.error('Error while reloading settings.json: ');
-		logger.error(err);
-	}
-	const value = db.getData('/')[key];
-	return (value !== undefined);
-}
-
-export function 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;
-	}
-	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 (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);
-		}
-	}
-	db = new JsonDB(settingsJsonPath, true, true);
-}

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

@@ -1,75 +0,0 @@
-import electron from 'electron';
-import fs from 'fs';
-
-let app: Electron.App = null;
-let setupCompleted = false;
-if (process.type === 'renderer') {
-	app = electron.remote.app;
-} else {
-	app = electron.app;
-}
-
-const zulipDir = app.getPath('userData');
-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
-	// create zulip dir in userData folder to
-	// avoid errors
-	if (!setupCompleted) {
-		if (!fs.existsSync(zulipDir)) {
-			fs.mkdirSync(zulipDir);
-		}
-
-		if (!fs.existsSync(logDir)) {
-			fs.mkdirSync(logDir);
-		}
-
-		if (!fs.existsSync(certificatesDir)) {
-			fs.mkdirSync(certificatesDir);
-		}
-
-		// Migrate config files from app data folder to config folder inside app
-		// data folder. This will be done once when a user updates to the new version.
-		if (!fs.existsSync(configDir)) {
-			fs.mkdirSync(configDir);
-			const domainJson = `${zulipDir}/domain.json`;
-			const certificatesJson = `${zulipDir}/certificates.json`;
-			const settingsJson = `${zulipDir}/settings.json`;
-			const updatesJson = `${zulipDir}/updates.json`;
-			const windowStateJson = `${zulipDir}/window-state.json`;
-			const configData = [
-				{
-					path: domainJson,
-					fileName: 'domain.json'
-				},
-				{
-					path: certificatesJson,
-					fileName: 'certificates.json'
-				},
-				{
-					path: settingsJson,
-					fileName: 'settings.json'
-				},
-				{
-					path: updatesJson,
-					fileName: 'updates.json'
-				}
-			];
-			configData.forEach(data => {
-				if (fs.existsSync(data.path)) {
-					fs.copyFileSync(data.path, configDir + data.fileName);
-					fs.unlinkSync(data.path);
-				}
-			});
-			// 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);
-			}
-		}
-
-		setupCompleted = true;
-	}
-};

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

@@ -1,48 +0,0 @@
-import * as ConfigUtil from './config-util';
-
-// 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]: boolean;
-}
-
-interface Toggle {
-	dnd: boolean;
-	newSettings: Setting;
-}
-
-export function toggle(): Toggle {
-	const dnd = !ConfigUtil.getConfigItem('dnd', false);
-	const dndSettingList = ['showNotification', 'silent'];
-	if (process.platform === 'win32') {
-		dndSettingList.push('flashTaskbarOnMessage');
-	}
-
-	let newSettings: Setting;
-	if (dnd) {
-		const oldSettings: Setting = {};
-		newSettings = {};
-
-		// Iterate through the dndSettingList.
-		for (const settingName of dndSettingList) {
-			// Store the current value of setting.
-			oldSettings[settingName] = ConfigUtil.getConfigItem(settingName);
-			// New value of setting.
-			newSettings[settingName] = (settingName === 'silent');
-		}
-
-		// Store old value in oldSettings.
-		ConfigUtil.setConfigItem('dndPreviousSettings', oldSettings);
-	} else {
-		newSettings = ConfigUtil.getConfigItem('dndPreviousSettings');
-	}
-
-	for (const settingName of dndSettingList) {
-		ConfigUtil.setConfigItem(settingName, newSettings[settingName]);
-	}
-
-	ConfigUtil.setConfigItem('dnd', dnd);
-	return {dnd, newSettings};
-}

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

@@ -1,309 +1,191 @@
-import { JsonDB } from 'node-json-db';
+import fs from "node:fs";
+import path from "node:path";
 
-import escape from 'escape-html';
+import {app, dialog} from "@electron/remote";
-import request from 'request';
+import * as Sentry from "@sentry/electron";
-import fs from 'fs';
+import {JsonDB} from "node-json-db";
-import path from 'path';
+import {DataError} from "node-json-db/dist/lib/Errors";
-import Logger from './logger-util';
+import * as z from "zod";
-import { remote } from 'electron';
 
-import * as RequestUtil from './request-util';
+import * as EnterpriseUtil from "../../../common/enterprise-util";
-import * as EnterpriseUtil from './enterprise-util';
+import Logger from "../../../common/logger-util";
-import * as Messages from '../../../resources/messages';
+import * as Messages from "../../../common/messages";
-
+import type {ServerConf} from "../../../common/types";
-const { app, dialog } = remote;
+import {ipcRenderer} from "../typed-ipc-renderer";
-
-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
 });
 
-const defaultIconUrl = '../renderer/img/icon.png';
+const defaultIconUrl = "../renderer/img/icon.png";
 
-export let db: JsonDB;
+const serverConfSchema = z.object({
+  url: z.string(),
+  alias: z.string(),
+  icon: z.string(),
+});
+
+let db!: JsonDB;
+
+reloadDb();
 
-reloadDB();
 // Migrate from old schema
-if (db.getData('/').domain) {
+try {
-	addDomain({
+  const oldDomain = db.getObject<unknown>("/domain");
-		alias: 'Zulip',
+  if (typeof oldDomain === "string") {
-		url: db.getData('/domain')
+    (async () => {
+      await addDomain({
+        alias: "Zulip",
+        url: oldDomain,
       });
-	db.delete('/domain');
+      db.delete("/domain");
+    })();
+  }
+} catch (error: unknown) {
+  if (!(error instanceof DataError)) throw error;
 }
 
 export function getDomains(): ServerConf[] {
-	reloadDB();
+  reloadDb();
-	if (db.getData('/').domains === undefined) {
+  try {
+    return serverConfSchema.array().parse(db.getObject<unknown>("/domains"));
+  } catch (error: unknown) {
+    if (!(error instanceof DataError)) throw error;
     return [];
-	} else {
-		return db.getData('/domains');
   }
 }
 
 export function getDomain(index: number): ServerConf {
-	reloadDB();
+  reloadDb();
-	return db.getData(`/domains[${index}]`);
+  return serverConfSchema.parse(db.getObject<unknown>(`/domains[${index}]`));
 }
 
-export function shouldIgnoreCerts(url: string): boolean {
+export function updateDomain(index: number, server: ServerConf): void {
-	const domains = getDomains();
+  reloadDb();
-	for (const domain of domains) {
+  serverConfSchema.parse(server);
-		if (domain.url === url) {
-			return domain.ignoreCerts;
-		}
-	}
-	return null;
-}
-
-function updateDomain(index: number, server: ServerConf): void {
-	reloadDB();
   db.push(`/domains[${index}]`, server, true);
 }
 
-export async function addDomain(server: ServerConf): Promise<void> {
+export async function addDomain(server: {
-	const { ignoreCerts } = server;
+  url: string;
+  alias: string;
+  icon?: string;
+}): Promise<void> {
   if (server.icon) {
-		const localIconUrl = await saveServerIcon(server, ignoreCerts);
+    const localIconUrl = await saveServerIcon(server.icon);
     server.icon = localIconUrl;
-		db.push('/domains[]', server, true);
+    serverConfSchema.parse(server);
-		reloadDB();
+    db.push("/domains[]", server, true);
+    reloadDb();
   } else {
     server.icon = defaultIconUrl;
-		db.push('/domains[]', server, true);
+    serverConfSchema.parse(server);
-		reloadDB();
+    db.push("/domains[]", server, true);
+    reloadDb();
   }
 }
 
 export function removeDomains(): void {
-	db.delete('/domains');
+  db.delete("/domains");
-	reloadDB();
+  reloadDb();
 }
 
 export function removeDomain(index: number): boolean {
   if (EnterpriseUtil.isPresetOrg(getDomain(index).url)) {
     return false;
   }
+
   db.delete(`/domains[${index}]`);
-	reloadDB();
+  reloadDb();
   return true;
 }
 
 // Check if domain is already added
 export function duplicateDomain(domain: string): boolean {
   domain = formatUrl(domain);
-	return getDomains().some(server => server.url === domain);
+  return getDomains().some((server) => server.url === domain);
 }
 
-async function checkCertError(domain: string, serverConf: ServerConf, error: string, silent: boolean): Promise<ServerConf> {
+export async function checkDomain(
-	if (silent) {
+  domain: string,
-		// since getting server settings has already failed
+  silent = false,
-		return serverConf;
+): Promise<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();
-
-		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 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.');
+    throw new Error("This server has been added.");
   }
 
   domain = formatUrl(domain);
 
-	const serverConf = {
-		icon: defaultIconUrl,
-		url: domain,
-		alias: domain,
-		ignoreCerts
-	};
-
   try {
-		return await getServerSettings(domain, serverConf.ignoreCerts);
+    return await getServerSettings(domain);
-	} catch (err) {
+  } catch {
-		// 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 (certsError) {
-			const result = await checkCertError(domain, serverConf, error, silent);
-			return result;
-		} else {
     throw new Error(Messages.invalidZulipServerError(domain));
   }
-	}
 }
 
-async function getServerSettings(domain: string, ignoreCerts = false): Promise<ServerConf> {
+async function getServerSettings(domain: string): Promise<ServerConf> {
-	const serverSettingsOptions = {
+  return ipcRenderer.invoke("get-server-settings", domain);
-		url: domain + '/api/v1/server_settings',
-		...RequestUtil.requestOptions(domain, ignoreCerts)
-	};
-
-	return new Promise((resolve, reject) => {
-		request(serverSettingsOptions, (error: string, response: any) => {
-			if (!error && response.statusCode === 200) {
-				const data = JSON.parse(response.body);
-				if (Object.prototype.hasOwnProperty.call(data, '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));
-				}
-			} else {
-				reject(response);
-			}
-		});
-	});
 }
 
-export async function saveServerIcon(server: ServerConf, ignoreCerts = false): Promise<string> {
+export async function saveServerIcon(iconURL: string): Promise<string> {
-	const url = server.icon;
+  return ipcRenderer.invoke("save-server-icon", iconURL);
-	const domain = server.url;
-
-	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 = 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) => {
-				logger.log('Could not get server icon.');
-				logger.log(err);
-				logger.reportSentry(err);
-				resolve(defaultIconUrl);
-			});
-		} catch (err) {
-			logger.log('Could not get server icon.');
-			logger.log(err);
-			logger.reportSentry(err);
-			resolve(defaultIconUrl);
-		}
-	});
 }
 
-export async function updateSavedServer(url: string, index: number): Promise<void> {
+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 newServerConf = await checkDomain(url, true);
-		const localIconUrl = await saveServerIcon(newServerConf, ignoreCerts);
+    const localIconUrl = await saveServerIcon(newServerConf.icon);
-		if (!oldIcon || localIconUrl !== '../renderer/img/icon.png') {
+    if (!oldIcon || localIconUrl !== "../renderer/img/icon.png") {
       newServerConf.icon = localIconUrl;
       updateDomain(index, newServerConf);
-			reloadDB();
+      reloadDb();
     }
-	} catch (err) {
+  } catch (error: unknown) {
-		logger.log('Could not update server icon.');
+    logger.log("Could not update server icon.");
-		logger.log(err);
+    logger.log(error);
-		logger.reportSentry(err);
+    Sentry.captureException(error);
   }
 }
 
-export function reloadDB(): void {
+function reloadDb(): void {
-	const domainJsonPath = path.join(app.getPath('userData'), 'config/domain.json');
+  const domainJsonPath = path.join(
+    app.getPath("userData"),
+    "config/domain.json",
+  );
   try {
-		const file = fs.readFileSync(domainJsonPath, 'utf8');
+    const file = fs.readFileSync(domainJsonPath, "utf8");
     JSON.parse(file);
-	} catch (err) {
+  } catch (error: unknown) {
     if (fs.existsSync(domainJsonPath)) {
       fs.unlinkSync(domainJsonPath);
       dialog.showErrorBox(
-				'Error saving new organization',
+        "Error saving new organization",
-				'There seems to be error while saving new organization, ' +
+        "There seems to be error while saving new organization, " +
-				'you may have to re-add your previous organizations back.'
+          "you may have to re-add your previous organizations back.",
       );
-			logger.error('Error while JSON parsing domain.json: ');
+      logger.error("Error while JSON parsing domain.json: ");
-			logger.error(err);
+      logger.error(error);
-			logger.reportSentry(err);
+      Sentry.captureException(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://')) {
+  if (domain.startsWith("http://") || domain.startsWith("https://")) {
     return domain;
   }
-	if (domain.startsWith('localhost:')) {
+
+  if (domain.startsWith("localhost:")) {
     return `http://${domain}`;
   }
+
   return `https://${domain}`;
 }

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

@@ -1,68 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-import Logger from './logger-util';
-
-const logger = new Logger({
-	file: 'enterprise-util.log',
-	timestamp: true
-});
-
-// todo: replace enterpriseSettings type with an interface once settings are final
-export let enterpriseSettings: any;
-export let configFile: boolean;
-
-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';
-	}
-
-	enterpriseFile = path.resolve(enterpriseFile);
-	if (fs.existsSync(enterpriseFile)) {
-		configFile = true;
-		try {
-			const file = fs.readFileSync(enterpriseFile, 'utf8');
-			enterpriseSettings = JSON.parse(file);
-		} catch (err) {
-			logger.log('Error while JSON parsing global_config.json: ');
-			logger.log(err);
-		}
-	} else {
-		configFile = false;
-	}
-}
-
-export function getConfigItem(key: string, defaultValue?: any): 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;
-	for (const org of presetOrgs) {
-		if (url.includes(org)) {
-			return true;
-		}
-	}
-	return false;
-}

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

@@ -1,45 +0,0 @@
-import { shell } from 'electron';
-import escape from 'escape-html';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-export function isUploadsUrl(server: string, url: URL): boolean {
-	return url.origin === server && url.pathname.startsWith('/user_uploads/');
-}
-
-export function openBrowser(url: URL): void {
-	if (['http:', 'https:', 'mailto:'].includes(url.protocol)) {
-		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);
-	}
-}

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

@@ -1,61 +0,0 @@
-import { JsonDB } from 'node-json-db';
-
-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;
-
-const logger = new Logger({
-	file: 'linux-update-util.log',
-	timestamp: true
-});
-
-/* To make the util runnable in both main and renderer process */
-const { dialog, app } = remote;
-
-let db: JsonDB;
-
-reloadDB();
-
-export function getUpdateItem(key: string, defaultValue: any = null): any {
-	reloadDB();
-	const value = db.getData('/')[key];
-	if (value === undefined) {
-		setUpdateItem(key, defaultValue);
-		return defaultValue;
-	} else {
-		return value;
-	}
-}
-
-export function setUpdateItem(key: string, value: any): 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 (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);
-		}
-	}
-	db = new JsonDB(linuxUpdateJsonPath, true, true);
-}

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

@@ -1,153 +0,0 @@
-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 fs from 'fs';
-import os from 'os';
-import isDev from 'electron-is-dev';
-import electron from '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;
-}
-
-interface LoggerOptions {
-	timestamp?: true | (() => string);
-	file?: string;
-	level?: boolean;
-	logInDevMode?: boolean;
-}
-
-initSetUp();
-
-let app: Electron.App = null;
-let reportErrors = true;
-if (process.type === 'renderer') {
-	app = electron.remote.app;
-
-	// 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;
-	ipcRenderer.send('error-reporting');
-	ipcRenderer.on('error-reporting-val', (_event: any, errorReporting: boolean) => {
-		reportErrors = errorReporting;
-		if (reportErrors) {
-			sentryInit();
-		}
-	});
-} else {
-	app = electron.app;
-}
-
-const browserConsole: PatchedConsole = console;
-const logDir = `${app.getPath('userData')}/Logs`;
-
-export default class Logger {
-	nodeConsole: PatchedConsole;
-	timestamp?: () => string;
-	level: boolean;
-	logInDevMode: boolean;
-	[key: string]: any;
-
-	constructor(options: LoggerOptions = {}) {
-		let {
-			timestamp = true,
-			file = 'console.log',
-			level = true,
-			logInDevMode = false
-		} = options;
-
-		file = `${logDir}/${file}`;
-		if (timestamp === true) {
-			timestamp = this.getTimestamp;
-		}
-
-		// Trim log according to type of process
-		if (process.type === 'renderer') {
-			requestIdleCallback(() => this.trimLog(file));
-		} else {
-			process.nextTick(() => this.trimLog(file));
-		}
-
-		const fileStream = fs.createWriteStream(file, { flags: 'a' });
-		const nodeConsole = new NodeConsole(fileStream);
-
-		this.nodeConsole = nodeConsole;
-		this.timestamp = timestamp;
-		this.level = level;
-		this.logInDevMode = logInDevMode;
-		this.setUpConsole();
-	}
-
-	_log(type: string, ...args: any[]): 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):
-				args.unshift(type.toUpperCase() + ' |');
-
-			case isDev || logInDevMode:
-				nodeConsoleLog = nodeConsole[type] || nodeConsole.log;
-				nodeConsoleLog.apply(null, args); // eslint-disable-line prefer-spread
-
-			default: break;
-		}
-		/* eslint-enable no-fallthrough */
-
-		browserConsole[type].apply(null, args);
-	}
-
-	setUpConsole(): void {
-		for (const type of Object.keys(browserConsole)) {
-			this.setupConsoleMethod(type);
-		}
-	}
-
-	setupConsoleMethod(type: string): void {
-		this[type] = (...args: any[]) => {
-			const log = this._log.bind(this, type, ...args);
-			log();
-		};
-	}
-
-	getTimestamp(): string {
-		const date = new Date();
-		const timestamp =
-			`${date.getMonth()}/${date.getDate()} ` +
-			`${date.getMinutes()}:${date.getSeconds()}`;
-		return timestamp;
-	}
-
-	reportSentry(err: string): void {
-		if (reportErrors) {
-			captureException(err);
-		}
-	}
-
-	trimLog(file: string): void{
-		fs.readFile(file, 'utf8', (err, data) => {
-			if (err) {
-				throw err;
-			}
-			const MAX_LOG_FILE_LINES = 500;
-			const logs = data.split(os.EOL);
-			const logLength = logs.length - 1;
-
-			// Keep bottom MAX_LOG_FILE_LINES of each log instance
-			if (logLength > MAX_LOG_FILE_LINES) {
-				const trimmedLogs = logs.slice(logLength - MAX_LOG_FILE_LINES);
-				const toWrite = trimmedLogs.join(os.EOL);
-				fs.writeFileSync(file, toWrite);
-			}
-		});
-	}
-}

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

@@ -1,118 +0,0 @@
-import * as ConfigUtil from './config-util';
-
-export interface ProxyRule {
-	hostname?: string;
-	port?: number;
-}
-
-// 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 (err) {
-		return;
-	}
-
-	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;
-	}
-}
-
-// 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,15 +1,12 @@
-import { ipcRenderer } from 'electron';
+import * as backoff from "backoff";
 
-import type WebView from '../components/webview';
+import {html} from "../../../common/html";
-import backoff from 'backoff';
+import Logger from "../../../common/logger-util";
-import request from 'request';
+import type WebView from "../components/webview";
-import Logger from './logger-util';
+import {ipcRenderer} from "../typed-ipc-renderer";
-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
 });
 
 export default class ReconnectUtil {
@@ -22,43 +19,19 @@ export default class ReconnectUtil {
     this.webview = webview;
     this.url = webview.props.url;
     this.alreadyReloaded = false;
-		this.clearState();
-	}
-
-	clearState(): void {
     this.fibonacciBackoff = backoff.fibonacci({
       initialDelay: 5000,
-			maxDelay: 300000
+      maxDelay: 300_000,
     });
   }
 
   async isOnline(): Promise<boolean> {
-		return new Promise(resolve => {
+    return ipcRenderer.invoke("is-online", this.url);
-			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) => {
-						const isValidResponse =
-							!error && response.statusCode >= 200 && response.statusCode < 400;
-						resolve(isValidResponse);
-					}
-				);
-			} catch (err) {
-				logger.log(err);
-			}
-		});
   }
 
   pollInternetAndReload(): void {
     this.fibonacciBackoff.backoff();
-		this.fibonacciBackoff.on('ready', async () => {
+    this.fibonacciBackoff.on("ready", async () => {
       if (await this._checkAndReload()) {
         this.fibonacciBackoff.reset();
       } else {
@@ -71,18 +44,24 @@ export default class ReconnectUtil {
     if (this.alreadyReloaded) {
       return true;
     }
+
     if (await this.isOnline()) {
-			ipcRenderer.send('forward-message', 'reload-viewer');
+      ipcRenderer.send("forward-message", "reload-viewer");
-			logger.log('You\'re back online.');
+      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');
+    logger.log(
+      "There is no internet connection, try checking network cables, modem and router.",
+    );
+    const errorMessageHolder = document.querySelector("#description");
     if (errorMessageHolder) {
-			errorMessageHolder.innerHTML = `
+      errorMessageHolder.innerHTML = html`
         <div>Your internet connection doesn't seem to work properly!</div>
-						<div>Verify that it works and then click try again.</div>`;
+        <div>Verify that it works and then click try again.</div>
+      `.html;
     }
+
     return false;
   }
 }