Auditing async usage in frontend code

emain/emain-window.ts

@@ -165,7 +165,7 @@ export class WaveBrowserWindow extends BaseWindow {
             }
             focusedWaveWindow = this;
             console.log("focus win", this.waveWindowId);
-            fireAndForget(async () => await ClientService.FocusWindow(this.waveWindowId));
+            fireAndForget(() => ClientService.FocusWindow(this.waveWindowId));
             setWasInFg(true);
             setWasActive(true);
         });
@@ -235,7 +235,7 @@ export class WaveBrowserWindow extends BaseWindow {
             }
             if (this.deleteAllowed) {
                 console.log("win removing window from backend DB", this.waveWindowId);
-                fireAndForget(async () => await WindowService.CloseWindow(this.waveWindowId, true));
+                fireAndForget(() => WindowService.CloseWindow(this.waveWindowId, true));
             }
             for (const tabView of this.allTabViews.values()) {
                 tabView?.destroy();

emain/emain.ts

@@ -368,7 +368,7 @@ electron.ipcMain.on("quicklook", (event, filePath: string) => {
 
 electron.ipcMain.on("open-native-path", (event, filePath: string) => {
     console.log("open-native-path", filePath);
-    fireAndForget(async () =>
+    fireAndForget(() =>
         electron.shell.openPath(filePath).then((excuse) => {
             if (excuse) console.error(`Failed to open ${filePath} in native application: ${excuse}`);
         })

emain/updater.ts

@@ -96,7 +96,7 @@ export class Updater {
                 body: "A new version of Wave Terminal is ready to install.",
             });
             updateNotification.on("click", () => {
-                fireAndForget(() => this.promptToInstallUpdate());
+                fireAndForget(this.promptToInstallUpdate.bind(this));
             });
             updateNotification.show();
         });
@@ -188,7 +188,7 @@ export class Updater {
         if (allWindows.length > 0) {
             await dialog.showMessageBox(focusedWaveWindow ?? allWindows[0], dialogOpts).then(({ response }) => {
                 if (response === 0) {
-                    fireAndForget(async () => this.installUpdate());
+                    fireAndForget(this.installUpdate.bind(this));
                 }
             });
         }
@@ -210,7 +210,7 @@ export function getResolvedUpdateChannel(): string {
     return isDev() ? "dev" : (autoUpdater.channel ?? "latest");
 }
 
-ipcMain.on("install-app-update", () => fireAndForget(() => updater?.promptToInstallUpdate()));
+ipcMain.on("install-app-update", () => fireAndForget(updater?.promptToInstallUpdate.bind(updater)));
 ipcMain.on("get-app-update-status", (event) => {
     event.returnValue = updater?.status;
 });

frontend/app/modals/tos.tsx

@@ -12,6 +12,7 @@ import { FlexiModal } from "./modal";
 import { QuickTips } from "@/app/element/quicktips";
 import { atoms, getApi } from "@/app/store/global";
 import { modalsModel } from "@/app/store/modalmodel";
+import { fireAndForget } from "@/util/util";
 import { atom, PrimitiveAtom, useAtom, useAtomValue, useSetAtom } from "jotai";
 import "./tos.scss";
 
@@ -20,25 +21,22 @@ const pageNumAtom: PrimitiveAtom<number> = atom<number>(1);
 const ModalPage1 = () => {
     const settings = useAtomValue(atoms.settingsAtom);
     const clientData = useAtomValue(atoms.client);
-    const [tosOpen, setTosOpen] = useAtom(modalsModel.tosOpen);
     const [telemetryEnabled, setTelemetryEnabled] = useState<boolean>(!!settings["telemetry:enabled"]);
     const setPageNum = useSetAtom(pageNumAtom);
 
     const acceptTos = () => {
         if (!clientData.tosagreed) {
-            services.ClientService.AgreeTos();
+            fireAndForget(services.ClientService.AgreeTos);
         }
         setPageNum(2);
     };
 
     const setTelemetry = (value: boolean) => {
-        services.ClientService.TelemetryUpdate(value)
-            .then(() => {
+        fireAndForget(() =>
+            services.ClientService.TelemetryUpdate(value).then(() => {
                 setTelemetryEnabled(value);
             })
-            .catch((error) => {
-                console.error("failed to set telemetry:", error);
-            });
+        );
     };
 
     const label = telemetryEnabled ? "Telemetry Enabled" : "Telemetry Disabled";

frontend/app/modals/userinputmodal.tsx

@@ -5,9 +5,9 @@ import { Modal } from "@/app/modals/modal";
 import { Markdown } from "@/element/markdown";
 import { modalsModel } from "@/store/modalmodel";
 import * as keyutil from "@/util/keyutil";
-import { UserInputService } from "../store/services";
-
+import { fireAndForget } from "@/util/util";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { UserInputService } from "../store/services";
 import "./userinputmodal.scss";
 
 const UserInputModal = (userInputRequest: UserInputRequest) => {
@@ -16,33 +16,39 @@ const UserInputModal = (userInputRequest: UserInputRequest) => {
     const checkboxRef = useRef<HTMLInputElement>();
 
     const handleSendErrResponse = useCallback(() => {
-        UserInputService.SendUserInputResponse({
-            type: "userinputresp",
-            requestid: userInputRequest.requestid,
-            errormsg: "Canceled by the user",
-        });
+        fireAndForget(() =>
+            UserInputService.SendUserInputResponse({
+                type: "userinputresp",
+                requestid: userInputRequest.requestid,
+                errormsg: "Canceled by the user",
+            })
+        );
         modalsModel.popModal();
     }, [responseText, userInputRequest]);
 
     const handleSendText = useCallback(() => {
-        UserInputService.SendUserInputResponse({
-            type: "userinputresp",
-            requestid: userInputRequest.requestid,
-            text: responseText,
-            checkboxstat: checkboxRef?.current?.checked ?? false,
-        });
+        fireAndForget(() =>
+            UserInputService.SendUserInputResponse({
+                type: "userinputresp",
+                requestid: userInputRequest.requestid,
+                text: responseText,
+                checkboxstat: checkboxRef?.current?.checked ?? false,
+            })
+        );
         modalsModel.popModal();
     }, [responseText, userInputRequest]);
     console.log("bar");
 
     const handleSendConfirm = useCallback(
         (response: boolean) => {
-            UserInputService.SendUserInputResponse({
-                type: "userinputresp",
-                requestid: userInputRequest.requestid,
-                confirm: response,
-                checkboxstat: checkboxRef?.current?.checked ?? false,
-            });
+            fireAndForget(() =>
+                UserInputService.SendUserInputResponse({
+                    type: "userinputresp",
+                    requestid: userInputRequest.requestid,
+                    confirm: response,
+                    checkboxstat: checkboxRef?.current?.checked ?? false,
+                })
+            );
             modalsModel.popModal();
         },
         [userInputRequest]

frontend/app/store/keymodel.ts

@@ -19,6 +19,7 @@ import {
 } from "@/layout/index";
 import { getLayoutModelForStaticTab } from "@/layout/lib/layoutModelHooks";
 import * as keyutil from "@/util/keyutil";
+import { fireAndForget } from "@/util/util";
 import * as jotai from "jotai";
 
 const simpleControlShiftAtom = jotai.atom(false);
@@ -83,7 +84,7 @@ function genericClose(tabId: string) {
         return;
     }
     const layoutModel = getLayoutModelForTab(tabAtom);
-    layoutModel.closeFocusedNode();
+    fireAndForget(layoutModel.closeFocusedNode.bind(layoutModel));
 }
 
 function switchBlockByBlockNum(index: number) {

frontend/app/store/wos.ts

@@ -6,6 +6,7 @@
 import { waveEventSubscribe } from "@/app/store/wps";
 import { getWebServerEndpoint } from "@/util/endpoints";
 import { fetch } from "@/util/fetchutil";
+import { fireAndForget } from "@/util/util";
 import { atom, Atom, Getter, PrimitiveAtom, Setter, useAtomValue } from "jotai";
 import { useEffect } from "react";
 import { globalStore } from "./jotaiStore";
@@ -301,7 +302,7 @@ function setObjectValue<T extends WaveObj>(value: T, setFn?: Setter, pushToServe
     }
     setFn(wov.dataAtom, { value: value, loading: false });
     if (pushToServer) {
-        ObjectService.UpdateObject(value, false);
+        fireAndForget(() => ObjectService.UpdateObject(value, false));
     }
 }
 

frontend/app/tab/tab.tsx

@@ -6,6 +6,7 @@ import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
 import { Button } from "@/element/button";
 import { ContextMenuModel } from "@/store/contextmenu";
+import { fireAndForget } from "@/util/util";
 import { clsx } from "clsx";
 import { forwardRef, memo, useCallback, useEffect, useImperativeHandle, useRef, useState } from "react";
 import { ObjectService } from "../store/services";
@@ -72,14 +73,21 @@ const Tab = memo(
                 };
             }, []);
 
-            const handleRenameTab = (event) => {
+            const selectEditableText = useCallback(() => {
+                if (editableRef.current) {
+                    const range = document.createRange();
+                    const selection = window.getSelection();
+                    range.selectNodeContents(editableRef.current);
+                    selection.removeAllRanges();
+                    selection.addRange(range);
+                }
+            }, []);
+
+            const handleRenameTab: React.MouseEventHandler<HTMLDivElement> = (event) => {
                 event?.stopPropagation();
                 setIsEditable(true);
                 editableTimeoutRef.current = setTimeout(() => {
-                    if (editableRef.current) {
-                        editableRef.current.focus();
-                        document.execCommand("selectAll", false);
-                    }
+                    selectEditableText();
                 }, 0);
             };
 
@@ -88,20 +96,14 @@ const Tab = memo(
                 newText = newText || originalName;
                 editableRef.current.innerText = newText;
                 setIsEditable(false);
-                ObjectService.UpdateTabName(id, newText);
+                fireAndForget(() => ObjectService.UpdateTabName(id, newText));
                 setTimeout(() => refocusNode(null), 10);
             };
 
-            const handleKeyDown = (event) => {
+            const handleKeyDown: React.KeyboardEventHandler<HTMLDivElement> = (event) => {
                 if ((event.metaKey || event.ctrlKey) && event.key === "a") {
                     event.preventDefault();
-                    if (editableRef.current) {
-                        const range = document.createRange();
-                        const selection = window.getSelection();
-                        range.selectNodeContents(editableRef.current);
-                        selection.removeAllRanges();
-                        selection.addRange(range);
-                    }
+                    selectEditableText();
                     return;
                 }
                 // this counts glyphs, not characters
@@ -150,7 +152,10 @@ const Tab = memo(
                     let menu: ContextMenuItem[] = [
                         { label: isPinned ? "Unpin Tab" : "Pin Tab", click: () => onPinChange() },
                         { label: "Rename Tab", click: () => handleRenameTab(null) },
-                        { label: "Copy TabId", click: () => navigator.clipboard.writeText(id) },
+                        {
+                            label: "Copy TabId",
+                            click: () => fireAndForget(() => navigator.clipboard.writeText(id)),
+                        },
                         { type: "separator" },
                     ];
                     const fullConfig = globalStore.get(atoms.fullConfigAtom);
@@ -175,10 +180,11 @@ const Tab = memo(
                             }
                             submenu.push({
                                 label: preset["display:name"] ?? presetName,
-                                click: () => {
-                                    ObjectService.UpdateObjectMeta(oref, preset);
-                                    RpcApi.ActivityCommand(TabRpcClient, { settabtheme: 1 });
-                                },
+                                click: () =>
+                                    fireAndForget(async () => {
+                                        await ObjectService.UpdateObjectMeta(oref, preset);
+                                        await RpcApi.ActivityCommand(TabRpcClient, { settabtheme: 1 });
+                                    }),
                             });
                         }
                         menu.push({ label: "Backgrounds", type: "submenu", submenu }, { type: "separator" });

frontend/app/tab/tabbar.tsx

@@ -467,13 +467,12 @@ const TabBar = memo(({ workspace }: TabBarProps) => {
             // Reset dragging state
             setDraggingTab(null);
             // Update workspace tab ids
-            fireAndForget(
-                async () =>
-                    await WorkspaceService.UpdateTabIds(
-                        workspace.oid,
-                        tabIds.slice(pinnedTabCount),
-                        tabIds.slice(0, pinnedTabCount)
-                    )
+            fireAndForget(() =>
+                WorkspaceService.UpdateTabIds(
+                    workspace.oid,
+                    tabIds.slice(pinnedTabCount),
+                    tabIds.slice(0, pinnedTabCount)
+                )
             );
         }),
         []
@@ -579,9 +578,7 @@ const TabBar = memo(({ workspace }: TabBarProps) => {
     const handlePinChange = useCallback(
         (tabId: string, pinned: boolean) => {
             console.log("handlePinChange", tabId, pinned);
-            fireAndForget(async () => {
-                await WorkspaceService.ChangeTabPinning(workspace.oid, tabId, pinned);
-            });
+            fireAndForget(() => WorkspaceService.ChangeTabPinning(workspace.oid, tabId, pinned));
         },
         [workspace]
     );

frontend/app/tab/workspaceswitcher.tsx

@@ -189,12 +189,10 @@ const WorkspaceSwitcher = () => {
     }, []);
 
     const onDeleteWorkspace = useCallback((workspaceId: string) => {
-        fireAndForget(async () => {
-            getApi().deleteWorkspace(workspaceId);
-            setTimeout(() => {
-                fireAndForget(updateWorkspaceList);
-            }, 10);
-        });
+        getApi().deleteWorkspace(workspaceId);
+        setTimeout(() => {
+            fireAndForget(updateWorkspaceList);
+        }, 10);
     }, []);
 
     const isActiveWorkspaceSaved = !!(activeWorkspace.name && activeWorkspace.icon);
@@ -267,12 +265,10 @@ const WorkspaceSwitcherItem = ({
     const isCurrentWorkspace = activeWorkspace.oid === workspace.oid;
 
     const setWorkspace = useCallback((newWorkspace: Workspace) => {
-        fireAndForget(async () => {
-            if (newWorkspace.name != "") {
-                setObjectValue({ ...newWorkspace, otype: "workspace" }, undefined, true);
-            }
-            setWorkspaceEntry({ ...workspaceEntry, workspace: newWorkspace });
-        });
+        if (newWorkspace.name != "") {
+            setObjectValue({ ...newWorkspace, otype: "workspace" }, undefined, true);
+        }
+        setWorkspaceEntry({ ...workspaceEntry, workspace: newWorkspace });
     }, []);
 
     const isActive = !!workspaceEntry.windowId;