[chore-245] convert some "send" calls to "sendV2"

src/main/ipcs/bs-mods-ipcs.ts

@@ -6,35 +6,19 @@ import { IpcRequest } from "shared/models/ipc";
 import { Mod } from "shared/models/mods/mod.interface";
 import { InstallModsResult } from "shared/models/mods";
 import log from "electron-log";
+import { IpcService } from "../services/ipc.service";
+import { from } from "rxjs";
 
-ipcMain.on("get-available-mods", (event, request: IpcRequest<BSVersion>) => {
-    const utils = UtilsService.getInstance();
+const ipc = IpcService.getInstance();
+
+ipc.on<BSVersion>("get-available-mods", (req, reply) => {
     const modsManager = BsModsManagerService.getInstance();
-
-    modsManager
-        .getAvailableMods(request.args)
-        .then(mods => {
-            utils.ipcSend(request.responceChannel, { success: true, data: mods });
-        })
-        .catch(err => {
-            utils.ipcSend(request.responceChannel, { success: false });
-            log.error("ipc", "get-available-mods", err, request);
-        });
+    reply(from(modsManager.getAvailableMods(req.args)));
 });
 
-ipcMain.on("get-installed-mods", (event, request: IpcRequest<BSVersion>) => {
-    const utils = UtilsService.getInstance();
+ipc.on<BSVersion>("get-installed-mods", (req, reply) => {
     const modsManager = BsModsManagerService.getInstance();
-
-    modsManager
-        .getInstalledMods(request.args)
-        .then(mods => {
-            utils.ipcSend(request.responceChannel, { success: true, data: mods });
-        })
-        .catch(err => {
-            utils.ipcSend(request.responceChannel, { success: false });
-            log.error("ipc", "get-installed-mods", err, request);
-        });
+    reply(from(modsManager.getInstalledMods(req.args)));
 });
 
 ipcMain.on("install-mods", (event, request: IpcRequest<{ mods: Mod[]; version: BSVersion }>) => {

src/main/ipcs/bs-uninstall-ipcs.ts

@@ -1,17 +1,12 @@
-import { ipcMain } from "electron";
 import { BSVersion } from "shared/bs-version.interface";
-import { UtilsService } from "../services/utils.service";
-import { IpcRequest } from "shared/models/ipc";
 import { BSLocalVersionService } from "../services/bs-local-version.service";
+import { IpcService } from "../services/ipc.service";
+import { from } from "rxjs";
 
-ipcMain.on("bs.uninstall", async (event, request: IpcRequest<BSVersion>) => {
+const ipc = IpcService.getInstance();
+
+ipc.on<BSVersion>("bs.uninstall", (req, reply) => {
     const bsLocalVersionService = BSLocalVersionService.getInstance();
-    const utilsService = UtilsService.getInstance();
 
-    if (!request.args) {
-        utilsService.ipcSend(request.responceChannel, { success: false });
-    }
-
-    const res = await bsLocalVersionService.deleteVersion(request.args);
-    utilsService.ipcSend(request.responceChannel, { success: res });
+    reply(from(bsLocalVersionService.deleteVersion(req.args)));
 });

src/main/ipcs/launcher-ipcs.ts

@@ -2,6 +2,10 @@ import { ipcMain } from "electron";
 import { AutoUpdaterService } from "../services/auto-updater.service";
 import { IpcRequest } from "shared/models/ipc";
 import { UtilsService } from "../services/utils.service";
+import { IpcService } from "../services/ipc.service";
+import { from } from "rxjs";
+
+const ipc = IpcService.getInstance();
 
 ipcMain.on("download-update", async (event, request: IpcRequest<void>) => {
     const updaterService = AutoUpdaterService.getInstance();
@@ -13,16 +17,11 @@ ipcMain.on("download-update", async (event, request: IpcRequest<void>) => {
         .catch(() => utilsService.ipcSend(request.responceChannel, { success: false }));
 });
 
-ipcMain.on("check-update", async (event, request: IpcRequest<void>) => {
+ipc.on("check-update", (_, reply) => {
     const updaterService = AutoUpdaterService.getInstance();
     const utilsService = UtilsService.getInstance();
 
-    updaterService
-        .isUpdateAvailable()
-        .then(updateAvailable => {
-            utilsService.ipcSend(request.responceChannel, { success: true, data: updateAvailable });
-        })
-        .catch(() => utilsService.ipcSend(request.responceChannel, { success: false }));
+    reply(from(updaterService.isUpdateAvailable()));
 });
 
 ipcMain.on("install-update", async (event, request: IpcRequest<void>) => {

src/main/ipcs/os-controls-ipcs.ts

@@ -5,17 +5,12 @@ import { SystemNotificationOptions } from "shared/models/notification/system-not
 import { NotificationService } from "../services/notification.service";
 import { SteamService } from "../services/steam.service";
 import { IpcService } from "../services/ipc.service";
-import { from } from "rxjs";
+import { from, of } from "rxjs";
 
 // TODO IMPROVE WINDOW CONTROL BY USING WINDOW SERVICE
 
 const ipc = IpcService.getInstance();
 
-ipcMain.on("window.close", async () => {
-    const utils = UtilsService.getInstance();
-    utils.getMainWindows("index.html")?.close();
-});
-
 ipcMain.on("window.maximize", async () => {
     const utils = UtilsService.getInstance();
     utils.getMainWindows("index.html")?.maximize();
@@ -35,7 +30,7 @@ ipcMain.on("new-window", async (event, request: IpcRequest<string>) => {
     shell.openExternal(request.args);
 });
 
-ipc.on("choose-folder", async (req: IpcRequest<string>, reply) => {
+ipc.on<string>("choose-folder", async (req, reply) => {
     reply(from(dialog.showOpenDialog({ properties: ["openDirectory"], defaultPath: req.args ?? "" })));
 });
 
@@ -54,8 +49,8 @@ ipcMain.on("save-file", async (event, request: IpcRequest<{ filename?: string; f
     });
 });
 
-ipcMain.on("current-version", async (event, request: IpcRequest<void>) => {
-    UtilsService.getInstance().ipcSend(request.responceChannel, { success: true, data: app.getVersion() });
+ipc.on("current-version", (_, reply) => {
+    reply(of(app.getVersion()));
 });
 
 ipcMain.on("open-logs", async (event, request: IpcRequest<void>) => {

src/main/ipcs/window-manager-ipcs.ts

@@ -1,32 +1,32 @@
-import { ipcMain } from "electron";
 import { WindowManagerService } from "../services/window-manager.service";
-import { IpcRequest } from "shared/models/ipc";
 import { AppWindow } from "shared/models/window-manager/app-window.model";
 import { BSLauncherService } from "../services/bs-launcher.service";
 import { IpcService } from "../services/ipc.service";
-import { from } from "rxjs";
+import { from, of } from "rxjs";
 
 const launcher = BSLauncherService.getInstance();
 const ipc = IpcService.getInstance();
 
-ipcMain.on("open-window-then-close-all", async (event, request: IpcRequest<AppWindow>) => {
+ipc.on<AppWindow>("open-window-then-close-all", (req, reply) => {
     const windowManager = WindowManagerService.getInstance();
 
-    windowManager.openWindow(request.args).then(window => {
-        windowManager.closeAllWindows(request.args);
+    const res = windowManager.openWindow(req.args).then(() => {
+        windowManager.closeAllWindows(req.args);
     });
+
+    reply(from(res));
 });
 
-ipcMain.on("close-all-windows", async (event, request: IpcRequest<AppWindow>) => {
+ipc.on<AppWindow>("close-all-windows", async (req, reply) => {
     await launcher.restoreSteamVR();
     const windowManager = WindowManagerService.getInstance();
-    windowManager.closeAllWindows(request.args);
+    reply(of(windowManager.closeAllWindows(req.args)));
 });
 
-ipcMain.on("close-windows", async (event, request: IpcRequest<AppWindow[]>) => {
+ipc.on<AppWindow[]>("close-windows", async (req, reply) => {
     await launcher.restoreSteamVR();
     const windowManager = WindowManagerService.getInstance();
-    windowManager.close(...request.args);
+    reply(of(windowManager.close(...req.args)));
 });
 
 ipc.on<AppWindow>("open-window-or-focus", (req, reply) => {

src/renderer/components/title-bar/title-bar.component.tsx

@@ -10,6 +10,7 @@ import { BsmRange } from "../shared/bsm-range.component";
 import { BsmIconType } from "../svgs/bsm-icon.component";
 import "./title-bar.component.css";
 import { useService } from "renderer/hooks/use-service.hook";
+import { lastValueFrom } from "rxjs";
 
 export default function TitleBar({ template = "index.html" }: { template: AppWindow }) {
     
@@ -23,11 +24,11 @@ export default function TitleBar({ template = "index.html" }: { template: AppWin
     const [previewVersion, setPreviewVersion] = useState(null);
 
     useEffect(() => {
-        ipcService.send<string>("current-version").then(res => {
-            if (res.data.toLocaleLowerCase().includes("alpha")) {
+        lastValueFrom(ipcService.sendV2<string>("current-version")).then(version => {
+            if (version.toLocaleLowerCase().includes("alpha")) {
                 return setPreviewVersion("ALPHA");
             }
-            if (res.data.toLocaleLowerCase().includes("beta")) {
+            if (version.toLocaleLowerCase().includes("beta")) {
                 return setPreviewVersion("BETA");
             }
         });

src/renderer/components/version-viewer/slides/mods/mods-slide.component.tsx

@@ -10,7 +10,7 @@ import BeatWaitingImg from "../../../../../../assets/images/apngs/beat-waiting.p
 import BeatConflictImg from "../../../../../../assets/images/apngs/beat-conflict.png";
 import { useObservable } from "renderer/hooks/use-observable.hook";
 import { skip, filter } from "rxjs/operators";
-import { Subscription } from "rxjs";
+import { Subscription, lastValueFrom } from "rxjs";
 import { useTranslation } from "renderer/hooks/use-translation.hook";
 import { LinkOpenerService } from "renderer/services/link-opener.service";
 import { useInView } from "framer-motion";
@@ -97,7 +97,10 @@ export function ModsSlide({ version, onDisclamerDecline }: { version: BSVersion;
             return;
         }
 
-        Promise.all([modsManager.getAvailableMods(version), modsManager.getInstalledMods(version)]).then(([available, installed]) => {
+        Promise.all([
+            lastValueFrom(modsManager.getAvailableMods(version)),
+            lastValueFrom(modsManager.getInstalledMods(version))
+        ]).then(([available, installed]) => {
             const defaultMods = configService.get<string[]>("default_mods" as DefaultConfigKey);
             setModsAvailable(modsToCategoryMap(available));
             setModsSelected(available.filter(m => m.required || defaultMods.some(d => m.name.toLowerCase() === d.toLowerCase()) || installed.some(i => m.name === i.name)));

src/renderer/pages/settings-page.component.tsx

@@ -79,7 +79,7 @@ export function SettingsPage() {
 
     useEffect(() => {
         loadInstallationFolder();
-        ipcService.send<string>("current-version").then(res => setAppVersion(res.data));
+        lastValueFrom(ipcService.sendV2<string>("current-version")).then(res => setAppVersion(res));
         mapsManager.isDeepLinksEnabled().then(enabled => setMapDeepLinksEnabled(() => enabled));
         playlistsManager.isDeepLinksEnabled().then(enabled => setPlaylistsDeepLinkEnabled(() => enabled));
         modelsManager.isDeepLinksEnabled().then(enabled => setModelsDeepLinkEnabled(() => enabled));

src/renderer/services/auto-updater.service.ts

@@ -1,4 +1,4 @@
-import { Observable } from "rxjs";
+import { Observable, lastValueFrom } from "rxjs";
 import { map } from "rxjs/operators";
 import { IpcService } from "./ipc.service";
 import { ProgressBarService } from "./progress-bar.service";
@@ -26,12 +26,7 @@ export class AutoUpdaterService {
     }
 
     public isUpdateAvailable(): Promise<boolean> {
-        return this.ipcService.send<boolean>("check-update").then(res => {
-            if (!res.success) {
-                return false;
-            }
-            return res.data;
-        });
+        return lastValueFrom(this.ipcService.sendV2<boolean>("check-update")).catch(() => false);
     }
 
     public downloadUpdate(): Promise<boolean> {
@@ -40,6 +35,7 @@ export class AutoUpdaterService {
         });
 
         this.progressService.show(this.downloadProgress$, true);
+        
         return promise;
     }
 

src/renderer/services/bs-mods-manager.service.ts

@@ -41,12 +41,12 @@ export class BsModsManagerService {
         this.os = OsDiagnosticService.getInstance();
     }
 
-    public async getAvailableMods(version: BSVersion): Promise<Mod[]> {
-        return this.ipcService.send<Mod[], BSVersion>("get-available-mods", { args: version }).then(res => res.data);
+    public getAvailableMods(version: BSVersion): Observable<Mod[]> {
+        return this.ipcService.sendV2<Mod[], BSVersion>("get-available-mods", { args: version });
     }
 
-    public async getInstalledMods(version: BSVersion): Promise<Mod[]> {
-        return this.ipcService.send<Mod[], BSVersion>("get-installed-mods", { args: version }).then(res => res.data);
+    public getInstalledMods(version: BSVersion): Observable<Mod[]> {
+        return this.ipcService.sendV2<Mod[], BSVersion>("get-installed-mods", { args: version });
     }
 
     public installMods(mods: Mod[], version: BSVersion): Promise<void> {

src/renderer/services/bs-uninstaller.service.ts

@@ -1,5 +1,6 @@
 import { BSVersion } from "shared/bs-version.interface";
 import { IpcService } from "./ipc.service";
+import { lastValueFrom } from "rxjs";
 
 export class BSUninstallerService {
     private static instance: BSUninstallerService;
@@ -17,7 +18,7 @@ export class BSUninstallerService {
         this.ipcService = IpcService.getInstance();
     }
 
-    public async uninstall(version: BSVersion): Promise<boolean> {
-        return (await this.ipcService.send("bs.uninstall", { args: version })).success;
+    public uninstall(version: BSVersion): Promise<boolean> {
+        return lastValueFrom(this.ipcService.sendV2<boolean>("bs.uninstall", { args: version })).catch(() => false);
     }
 }

src/renderer/services/ipc.service.ts

@@ -18,6 +18,9 @@ export class IpcService {
         this.channelObservables = new Map<string, Observable<IpcResponse<unknown>>>();
     }
 
+    /**
+     * @deprecated use sendV2 instead
+     */
     public send<T, U = unknown>(channel: string, request?: IpcRequest<U>): Promise<IpcResponse<T>> {
         if (!request) {
             request = { args: null, responceChannel: null };

src/renderer/services/window-manager.service.ts

@@ -18,16 +18,16 @@ export class WindowManagerService {
         this.ipcService = IpcService.getInstance();
     }
 
-    public openThenCloseAll(window: AppWindow) {
-        this.ipcService.sendLazy<AppWindow>("open-window-then-close-all", { args: window });
+    public openThenCloseAll(window: AppWindow): Promise<void> {
+        return lastValueFrom(this.ipcService.sendV2<void>("open-window-then-close-all", { args: window }));
     }
 
-    public closeAll(except?: AppWindow) {
-        this.ipcService.sendLazy<AppWindow>("close-all-windows", { args: except });
+    public closeAll(except?: AppWindow): Promise<void> {
+        return lastValueFrom(this.ipcService.sendV2<void>("close-all-windows", { args: except }));
     }
 
-    public close(...win: AppWindow[]) {
-        this.ipcService.sendLazy<AppWindow[]>("close-windows", { args: win });
+    public close(...win: AppWindow[]): Promise<void> {
+        return lastValueFrom(this.ipcService.sendV2<void>("close-windows", { args: win }));
     }
 
     public openWindowOrFocus(window: AppWindow): Promise<void> {