bumb version

[hotfix] move instead of copy if no other version use the linked folder

README.md

@@ -43,7 +43,7 @@
     <a href="https://github.com/Zagrios/bs-manager/issues"><img alt="GitHub issues" src="https://img.shields.io/github/issues/Zagrios/bs-manager?style=for-the-badge"></a>
     <br>
     <a href="https://discord.gg/uSqbHVpKdV"><img src ="https://img.shields.io/badge/-DISCORD-5865f2?style=for-the-badge&logo=discord&logoColor=ffffff" alt="discord"/></a>
-    <!--<a href="https://mee6.xyz/fr/m/bsmanager"><img src ="https://img.shields.io/badge/-🥰%20Support%20BSM-EC4546?style=for-the-badge" alt="Donation"/></a>-->
+    <a href="https://www.patreon.com/bsmanager"><img src ="https://img.shields.io/badge/-🥰%20Support%20BSM-EC4546?style=for-the-badge" alt="Donation"/></a>
     <a href="https://twitter.com/BSManager_"><img src ="https://img.shields.io/badge/-Twitter-F5F8FA?style=for-the-badge&logo=Twitter" alt="Twitter"/></a>
     <br>
     [<a href="#readme-bot">Go to bottom</a>]

release/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bs-manager",
-  "version": "1.1.0-alpha.1",
+  "version": "1.1.0-alpha.3",
   "description": "A foundation for scalable desktop apps",
   "main": "./dist/main/main.js",
   "author": {

src/main/helpers/fs.helpers.ts

@@ -1,4 +1,4 @@
-import { move } from "fs-extra";
+import { copyFile, ensureDir, move, symlink } from "fs-extra";
 import { access, mkdir, rm, readdir, unlink, lstat, readlink } from "fs/promises";
 import path from "path";
 import { Observable } from "rxjs";
@@ -81,6 +81,27 @@ export function moveFolderContent(src: string, dest: string): Observable<Progres
     });
 }
 
+export async function copyDirectoryWithJunctions(source: string, destination: string): Promise<void> {
+    
+    await ensureDir(destination);
+    const items = await readdir(source);
+  
+    for (const item of items) {
+        const sourcePath = path.join(source, item);
+        const destinationPath = path.join(destination, item);
+        const stats = await lstat(sourcePath);
+
+        if (stats.isDirectory()) {
+            await copyDirectoryWithJunctions(sourcePath, destinationPath);
+        } else if (stats.isFile()) {
+            await copyFile(sourcePath, destinationPath);
+        } else if (stats.isSymbolicLink()) {
+            const symlinkTarget = await readlink(sourcePath);
+            await symlink(symlinkTarget, destinationPath, "junction");
+        }
+    }
+}
+
 export interface Progression<T = unknown>{
     total: number;
     current: number;

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

@@ -14,6 +14,8 @@ import { FolderLinkerService, LinkOptions } from '../services/folder-linker.serv
 import { LocalMapsManagerService } from '../services/additional-content/local-maps-manager.service';
 import { readJSON, writeJSON } from 'fs-extra';
 import log from "electron-log"
+import { VersionLinkerAction } from 'renderer/services/version-folder-linker.service';
+import { VersionFolderLinkerService } from '../services/version-folder-linker.service';
 
 const ipc = IpcService.getInstance();
 
@@ -57,9 +59,7 @@ ipcMain.on("bs-version.clone", async (event, req: IpcRequest<{version: BSVersion
 
 ipc.on("get-version-full-path", async (req: IpcRequest<BSVersion>, reply) => {
     const localVersions = BSLocalVersionService.getInstance();
-    reply(from(
-        localVersions.getVersionPath(req.args)
-    ));
+    reply(from( localVersions.getVersionPath(req.args) ));
 });
 
 ipc.on("relative-version-path-to-full", async (req: IpcRequest<{version: BSVersion, relative: string}>, reply) => {
@@ -80,9 +80,9 @@ ipc.on("full-version-path-to-relative", async (req: IpcRequest<{version: BSVersi
     reply(from(promise));
 });
 
-ipc.on("get-linked-folders", async (req: IpcRequest<BSVersion>, reply) => {
-    const localVersions = BSLocalVersionService.getInstance();
-    reply(from(localVersions.getLinkedFolders(req.args)));
+ipc.on("get-linked-folders", async (req: IpcRequest<{version: BSVersion, options?: { relative?: boolean }}>, reply) => {
+    const versionLinker = VersionFolderLinkerService.getInstance();
+    reply(from(versionLinker.getLinkedFolders(req.args.version, req.args.options)));
 });
 
 ipc.on("link-folder", async (req: IpcRequest<{ folder: string, options?: LinkOptions}>, reply) => {
@@ -121,6 +121,16 @@ ipc.on("link-folder", async (req: IpcRequest<{ folder: string, options?: LinkOpt
 
 });
 
+ipc.on("link-version-folder-action", async (req: IpcRequest<VersionLinkerAction>, reply) => {
+    const versionLinker = VersionFolderLinkerService.getInstance();
+    reply(from(versionLinker.doAction(req.args)));
+});
+
+ipc.on("is-version-folder-linked", async (req: IpcRequest<{ version: BSVersion, relativeFolder: string }>, reply) => {
+    const versionLinker = VersionFolderLinkerService.getInstance();
+    reply(from(versionLinker.isFolderLinked(req.args.version, req.args.relativeFolder)));
+});
+
 ipc.on("unlink-folder", async (req: IpcRequest<{ folder: string, options?: LinkOptions}>, reply) => {
 
     req.args.options ??= {};

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

@@ -77,15 +77,4 @@ ipcMain.on("open-steam", async (event, request: IpcRequest<void>) => {
     }).catch((e) => {
         utils.ipcSend(request.responceChannel, {success: false, error: e});
     });
-});
-
-ipc.on("is-folder-symlink", async (req: IpcRequest<string>, reply) => {
-    const promise = new Promise<boolean>(async resolve => {
-        if(!(await pathExist(req.args))){ return resolve(false); }
-        lstat(req.args, (err, stats) => {
-            if(err){ return resolve(false); }
-            resolve(stats.isSymbolicLink());
-        });
-    }); 
-    reply(from(promise));
 });

src/main/main.ts

@@ -9,7 +9,7 @@
  * `./src/main.js` using webpack. This gives us some performance wins.
  */
 import path from 'path';
-import { app, protocol } from 'electron';
+import { app, ipcMain, protocol } from 'electron';
 import log from 'electron-log';
 import './ipcs';
 import { UtilsService } from './services/utils.service';
@@ -21,6 +21,7 @@ import { LocalPlaylistsManagerService } from './services/additional-content/loca
 import { LocalModelsManagerService } from './services/additional-content/local-models-manager.service';
 import { APP_NAME } from './constants';
 import { BSLauncherService } from './services/bs-launcher.service';
+import { IpcRequest } from 'shared/models/ipc';
 
 const isDebug = process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true';
 
@@ -100,5 +101,10 @@ else{
 
         BSLauncherService.getInstance().restoreSteamVR();
 
+        // Log renderer errors
+        ipcMain.on('log-error', (event, args: IpcRequest<any>) => {
+            log.error(args?.args);
+        });
+
     }).catch(log.error);
 }

src/main/services/bs-launcher.service.ts

@@ -41,14 +41,14 @@ export class BSLauncherService{
     private async backupSteamVR(): Promise<void>{
         const steamVrFolder = await this.getSteamVRPath();
         if(!await pathExist(steamVrFolder)){ return; }
-        return rename(steamVrFolder, steamVrFolder + ".bak");
+        return rename(steamVrFolder, steamVrFolder + ".bak").catch(log.error);
     }
 
     public async restoreSteamVR(): Promise<void>{
         const steamVrFolder = await this.getSteamVRPath();
         const steamVrBackup = steamVrFolder + ".bak";
         if(!await pathExist(steamVrBackup)){ return; }
-        return rename(steamVrFolder + ".bak", steamVrFolder);
+        return rename(steamVrFolder + ".bak", steamVrFolder).catch(log.error);
     }
 
     public isBsRunning(): boolean{
@@ -75,12 +75,13 @@ export class BSLauncherService{
 
         launchArgs = Array.from(new Set(launchArgs).values());
 
+        let restoreTimout: NodeJS.Timeout;
+
         if(launchArgs.includes("fpfc")){
-            await this.backupSteamVR().catch(e => {
-                log.error(e);
+            await this.backupSteamVR().catch(() => {
                 this.restoreSteamVR();
             }).finally(() => {
-                setTimeout(() => this.restoreSteamVR(), 35_000);
+                restoreTimout = setTimeout(() => this.restoreSteamVR(), 35_000);
             });
             await timer(2_000).toPromise();
         }
@@ -97,7 +98,7 @@ export class BSLauncherService{
 
         this.bsProcess.on('error', err => log.error(err));
         this.bsProcess.on('exit', code => {
-            this.restoreSteamVR();
+            this.restoreSteamVR().finally(() => clearTimeout(restoreTimout));
             this.utilsService.ipcSend("bs-launch.exit", {data: code, success: code === 0})
         });
 

src/main/services/bs-local-version.service.ts

@@ -5,7 +5,6 @@ import { SteamService } from "./steam.service";
 import { BS_APP_ID, OCULUS_BS_DIR } from "../constants";
 import path from "path";
 import { createReadStream } from "fs";
-import fs from "fs-extra";
 import { ConfigurationService } from "./configuration.service";
 import { rename } from "fs/promises";
 import { BsmException } from "shared/models/bsm-exception.model";
@@ -13,7 +12,7 @@ import log from "electron-log";
 import { OculusService } from "./oculus.service";
 import { DownloadLinkType } from "shared/models/mods";
 import sanitize from "sanitize-filename";
-import { deleteFolder, getFoldersInFolder, pathExist } from "../helpers/fs.helpers";
+import { copyDirectoryWithJunctions, deleteFolder, getFoldersInFolder, pathExist } from "../helpers/fs.helpers";
 import { FolderLinkerService } from "./folder-linker.service";
 
 export class BSLocalVersionService{
@@ -97,6 +96,7 @@ export class BSLocalVersionService{
    public async getVersionPath(version: BSVersion): Promise<string>{
       if(version.steam){ return this.steamService.getGameFolder(BS_APP_ID, "Beat Saber") }
       if(version.oculus){ return this.oculusService.getGameFolder(OCULUS_BS_DIR); }
+      console.log("getVersionPath", this.getVersionFolder(version), version);
       return path.join(
          this.installLocationService.versionsDirectory,
          this.getVersionFolder(version)
@@ -223,7 +223,7 @@ export class BSLocalVersionService{
 
       if(await pathExist(newPath)){ throw {title: "VersionAlreadExist"} as BsmException; }
 
-      return fs.copy(originPath, newPath, {dereference: true}).then(() => {
+      return copyDirectoryWithJunctions(originPath, newPath).then(() => {
          this.addCustomVersion(cloneVersion);
          return cloneVersion;
       }).catch((err: Error) => {

src/main/services/folder-linker.service.ts

@@ -52,13 +52,14 @@ export class FolderLinkerService {
 
         const sharedPath = this.getSharedFolder(folderPath, options?.intermediateFolder);
 
-        await ensureFolderExist(folderPath);
         await ensureFolderExist(sharedPath);
 
         if(options?.backup === true){
             await this.backupFolder(folderPath);
         }
 
+        await ensureFolderExist(folderPath);
+
         if(options?.keepContents !== false){
             await moveFolderContent(folderPath, sharedPath).toPromise();
         }
@@ -68,7 +69,7 @@ export class FolderLinkerService {
         return symlink(sharedPath, folderPath, "junction");
     }
 
-    public async unlinkFolder(folderPath: string, options?: LinkOptions): Promise<void> {
+    public async unlinkFolder(folderPath: string, options?: UnlinkOptions): Promise<void> {
 
         if(!(await this.isFolderSymlink(folderPath))){ return; }
         await unlinkPath(folderPath);
@@ -81,10 +82,14 @@ export class FolderLinkerService {
             return this.restoreFolder(folderPath);
         }
 
+        if(options.moveContents === true){
+            return moveFolderContent(sharedPath, folderPath).toPromise().then(() => {});
+        }
+
         if(options?.keepContents === false){ return; }
 
         await ensureFolderExist(sharedPath);
-
+        
         return copy(sharedPath, folderPath, { errorOnExist: false, recursive: true });
     }
 
@@ -104,5 +109,9 @@ export class FolderLinkerService {
 export interface LinkOptions {
     keepContents?: boolean,
     intermediateFolder?: string,
-    backup?: boolean
-}
+    backup?: boolean,
+}
+
+export interface UnlinkOptions extends LinkOptions {
+    moveContents?: boolean,
+};

src/main/services/version-folder-linker.service.ts

@@ -0,0 +1,111 @@
+import { getFoldersInFolder, pathExist } from "../helpers/fs.helpers";
+import path from "path";
+import { VersionLinkerAction, VersionLinkFolderAction, VersionUnlinkFolderAction } from "renderer/services/version-folder-linker.service";
+import { BSVersion } from "shared/bs-version.interface";
+import { LocalMapsManagerService } from "./additional-content/local-maps-manager.service";
+import { BSLocalVersionService } from "./bs-local-version.service";
+import { FolderLinkerService, LinkOptions } from "./folder-linker.service";
+
+export class VersionFolderLinkerService {
+
+    private static instance: VersionFolderLinkerService;
+
+    public static getInstance(): VersionFolderLinkerService{
+        if(!VersionFolderLinkerService.instance){ VersionFolderLinkerService.instance = new VersionFolderLinkerService() }
+        return VersionFolderLinkerService.instance;
+    }
+
+    private readonly localVersion: BSLocalVersionService;
+    private readonly folderLinker: FolderLinkerService;
+
+    private constructor(){
+        this.localVersion = BSLocalVersionService.getInstance();
+        this.folderLinker = FolderLinkerService.getInstance();
+    }
+
+    private specialFolderOption(relativeFolder: string, options: LinkOptions): LinkOptions{
+        if(relativeFolder.includes(LocalMapsManagerService.CUSTOM_LEVELS_FOLDER)){
+            return {...options, intermediateFolder: LocalMapsManagerService.SHARED_MAPS_FOLDER};
+        }
+
+        if(relativeFolder.includes("UserData")){
+            return { ...options, backup: true };
+        }
+
+        return options ?? {};
+    }
+
+    private async isOtherVersionHaveFolderLinked(relativeFolder: string, ignorePath: string): Promise<boolean>{
+        const versions = await this.localVersion.getInstalledVersions();
+        const versionPaths = (await Promise.allSettled(versions.map(version => this.localVersion.getVersionPath(version)))).reduce((acc, res) => {
+            if(res.status === "fulfilled"){
+                acc.push(res.value);
+            }
+            return acc;
+        }, [] as string[]);
+
+        for(const versionPath of versionPaths){
+            const folderPath = this.relativeToFullPath(versionPath, relativeFolder);
+            if(folderPath === ignorePath){ continue; }
+            if(await this.folderLinker.isFolderSymlink(folderPath)){ console.log(folderPath); return true; }
+        }
+
+        return false;
+    }
+
+    private relativeToFullPath(parentPath: string, relativePath: string): string{
+        return path.join(parentPath, relativePath);
+    }
+
+
+    public async linkVersionFolder(action: VersionLinkerAction): Promise<boolean>{
+        action.options = this.specialFolderOption(action.relativeFolder, action.options);
+        const versionPath = await this.localVersion.getVersionPath(action.version);
+        const folderPath = this.relativeToFullPath(versionPath, action.relativeFolder);
+        return this.folderLinker.linkFolder(folderPath, action.options).catch(() => false).then(() => true)
+    }
+
+    public async unlinkVersionFolder(action: VersionUnlinkFolderAction): Promise<boolean>{
+        action.options = this.specialFolderOption(action.relativeFolder, action.options);
+
+        const versionPath = await this.localVersion.getVersionPath(action.version);
+        const folderPath = this.relativeToFullPath(versionPath, action.relativeFolder);
+
+        action.options.moveContents = !(await this.isOtherVersionHaveFolderLinked(action.relativeFolder, folderPath));
+
+        return this.folderLinker.unlinkFolder(folderPath, action.options).catch(() => false).then(() => true);
+    }
+
+    public async doAction(action: VersionLinkerAction): Promise<boolean>{
+        if(action.type === "link"){
+            return this.linkVersionFolder(action);
+        }
+        return this.unlinkVersionFolder(action as VersionUnlinkFolderAction);
+    }
+
+    public async isFolderLinked(version: BSVersion, relativeFolder: string): Promise<boolean>{
+        const versionPath = await this.localVersion.getVersionPath(version);
+        const folderPath = this.relativeToFullPath(versionPath, relativeFolder);
+        return this.folderLinker.isFolderSymlink(folderPath);
+    }
+
+    public async getLinkedFolders(version: BSVersion, options?: { relative?: boolean }): Promise<string[]>{
+        const versionPath = await this.localVersion.getVersionPath(version);
+        const [rootFolders, beatSaberDataFolders] = await Promise.all([
+            getFoldersInFolder(versionPath),
+            getFoldersInFolder(path.join(versionPath, "Beat Saber_Data"))
+        ]);
+
+        const linkedFolder = await Promise.all([...rootFolders, ...beatSaberDataFolders].map(async folder => {
+            if(!(await this.folderLinker.isFolderSymlink(folder))){ return null; }
+            return folder;   
+        }));
+
+        if(options?.relative){
+            return linkedFolder.filter(folder => folder).map(folder => path.relative(versionPath, folder));
+        }
+
+        return linkedFolder.filter(folder => folder);
+    }
+
+}

src/renderer/components/maps-mangement-components/local-maps-list-panel.component.tsx

@@ -9,7 +9,7 @@ import { MapsDownloaderService } from "renderer/services/maps-downloader.service
 import { VariableSizeList } from "react-window"
 import { MapsRow } from "./maps-row.component"
 import { BehaviorSubject } from "rxjs"
-import { debounceTime, last, map, mergeMap, throttleTime } from "rxjs/operators"
+import { debounceTime, last, map, mergeMap } from "rxjs/operators"
 import { BeatSaverService } from "renderer/services/thrird-partys/beat-saver.service"
 import { OsDiagnosticService } from "renderer/services/os-diagnostic.service"
 import { useTranslation } from "renderer/hooks/use-translation.hook"
@@ -64,6 +64,8 @@ export const LocalMapsListPanel = forwardRef(({version, className, filter, searc
 
     useEffect(() => {
 
+        console.log(linked);
+
         if(isVisible){
             loadMaps();
             mapsDownloader.addOnMapDownloadedListener((map, targerVersion) => {

src/renderer/components/maps-mangement-components/maps-playlists-panel.component.tsx

@@ -17,7 +17,8 @@ import { BsmIcon } from "../svgs/bsm-icon.component"
 import { useTranslation } from "renderer/hooks/use-translation.hook"
 import { LinkButton } from "./link-button.component"
 import { debounceTime } from "rxjs/operators"
-import { FolderLinkerService } from "renderer/services/folder-linker.service"
+import { VersionFolderLinkerService, VersionLinkerActionListener } from "renderer/services/version-folder-linker.service"
+
 
 type Props = {
     version?: BSVersion
@@ -28,7 +29,7 @@ export function MapsPlaylistsPanel({version}: Props) {
     const mapsService = MapsManagerService.getInstance();
     const mapsDownloader = MapsDownloaderService.getInstance();
     const osDiagnostic = OsDiagnosticService.getInstance();
-    const linker = FolderLinkerService.getInstance();
+    const linker = VersionFolderLinkerService.getInstance();
     
     const [tabIndex, setTabIndex] = useState(0);
     const [mapFilter, setMapFilter] = useState<MapFilter>({});
@@ -46,18 +47,18 @@ export function MapsPlaylistsPanel({version}: Props) {
 
         const sub = mapsService.$mapsLinkingPending(version).pipe(debounceTime(50)).subscribe(setLinkingPending);
 
-        const onMapsLinked = (folder: string) => {
-            if(!folder.includes("CustomLevels")){ return; }
+        const onMapsLinked: VersionLinkerActionListener = (action, linked) => {
+            if(!action.relativeFolder.includes(MapsManagerService.RELATIVE_MAPS_FOLDER)){ return; }
             loadMapIsLinked();
         }
 
-        linker.onFolderLinked(onMapsLinked);
-        linker.onFolderUnlinked(onMapsLinked);
+        linker.onVersionFolderLinked(onMapsLinked);
+        linker.onVersionFolderUnlinked(onMapsLinked);
 
         return () => {
             sub.unsubscribe();
-            linker.removeOnFolderLinked(onMapsLinked);
-            linker.removeOnFolderUnlinked(onMapsLinked);
+            linker.removeVersionFolderLinkedListener(onMapsLinked);
+            linker.removeVersionFolderUnlinkedListener(onMapsLinked);
         }
 
     }, [version]);

src/renderer/components/modal/modal-types/share-folders-modal.component.tsx

@@ -1,5 +1,6 @@
 import Tippy from "@tippyjs/react";
 import { Variants } from "framer-motion";
+import { version } from "os";
 import { useEffect, useState } from "react";
 import { LinkButton } from "renderer/components/maps-mangement-components/link-button.component";
 import { BsmBasicSpinner } from "renderer/components/shared/bsm-basic-spinner/bsm-basic-spinner.component";
@@ -8,10 +9,11 @@ import { BsmIcon } from "renderer/components/svgs/bsm-icon.component";
 import { useObservable } from "renderer/hooks/use-observable.hook";
 import { useThemeColor } from "renderer/hooks/use-theme-color.hook";
 import { useTranslation } from "renderer/hooks/use-translation.hook";
+import { BSVersionManagerService } from "renderer/services/bs-version-manager.service";
 import { ConfigurationService } from "renderer/services/configuration.service";
-import { FolderLinkerService } from "renderer/services/folder-linker.service";
 import { IpcService } from "renderer/services/ipc.service";
 import { ModalComponent } from "renderer/services/modale.service";
+import { VersionFolderLinkerService, VersionLinkerActionType } from "renderer/services/version-folder-linker.service";
 import { BSVersion } from "shared/bs-version.interface";
 
 export const ShareFoldersModal: ModalComponent<void, BSVersion> = ({ data }) => {
@@ -20,32 +22,18 @@ export const ShareFoldersModal: ModalComponent<void, BSVersion> = ({ data }) =>
 
     const config = ConfigurationService.getInstance();
     const ipc = IpcService.getInstance();
+    const linker = VersionFolderLinkerService.getInstance();
+    const versionManager = BSVersionManagerService.getInstance();
 
     const t = useTranslation();
 
     const [folders, setFolders] = useState<string[]>([]);
-    const versionPath = useObservable(ipc.sendV2<string>("get-version-full-path", {args: data}));
 
     useEffect(() => {
 
-        const defaultFolders = config.get<string[]>(SHARED_FOLDERS_KEY);
+        setFolders(prev => Array.from(new Set([...prev, ...config.get<string[]>(SHARED_FOLDERS_KEY)]).values()));
 
-        const promises = Promise.allSettled(defaultFolders.map(async (folder) => {
-            return ipc.sendV2<string>("relative-version-path-to-full", {args: {version: data, relative: folder}}).toPromise();
-        }));
-    
-        promises.then((res) => {
-
-            const fullPathFolders = res.reduce((acc, curent) => {
-                if(curent.status !== "fulfilled"){ return acc; }
-                acc.push(curent.value);
-                return acc;
-            }, []);
-
-            setFolders(prev => Array.from(new Set([...prev, ...fullPathFolders]).values()));
-        });
-
-        ipc.sendV2<string[]>("get-linked-folders", {args: data}).toPromise().then(linkedFolders => {
+        linker.getLinkedFolders(data, {relative: true}).toPromise().then(linkedFolders => {
             setFolders(prev => Array.from(new Set([...prev, ...linkedFolders]).values()));
         });
 
@@ -57,31 +45,22 @@ export const ShareFoldersModal: ModalComponent<void, BSVersion> = ({ data }) =>
             config.delete(SHARED_FOLDERS_KEY);
             return; 
         }
-
-        const promises = Promise.allSettled(folders.map(async folder => {
-            return ipc.sendV2<string>("full-version-path-to-relative", {args: {version: data, fullPath: folder}}).toPromise();
-        }));
-
-        promises.then((res) => {
-            const sharedFolders = res.reduce((acc, curent) => {
-                if(curent.status !== "fulfilled"){ return acc; }
-                acc.push(curent.value);
-                return acc;
-            }, [] as string[]);
-            config.set(SHARED_FOLDERS_KEY, sharedFolders);
-        });
+        
+        config.set(SHARED_FOLDERS_KEY, folders);
 
     }, [folders]);
 
     const addFolder = async () => {
+        const versionPath = await versionManager.getVersionPath(data).toPromise();
         const folder = await ipc.sendV2<{canceled: boolean, filePaths: string[]}, string>("choose-folder", {args: versionPath}).toPromise();
-        
+
         if(!folder || folder.canceled || !folder.filePaths?.length){ return; }
-        const linkedFolder = folder.filePaths[0];
 
-        if(folders.includes(linkedFolder)){ return; }
+        const relativeFolder = await ipc.sendV2<string>("full-version-path-to-relative", {args: {version: data, fullPath: folder.filePaths[0]}}).toPromise();
 
-        setFolders(pre => [...pre, linkedFolder]);
+        if(folders.includes(relativeFolder)){ return; }
+
+        setFolders(pre => [...pre, relativeFolder]);
     }
 
     const removeFolder = (index: number) => {
@@ -94,7 +73,7 @@ export const ShareFoldersModal: ModalComponent<void, BSVersion> = ({ data }) =>
             <p className="my-3">{t("modals.shared-folders.description")}</p>
             <ul className="flex flex-col gap-1 mb-2 h-[300px] max-h-[300px] overflow-scroll scrollbar-thin scrollbar-thumb-rounded-full scrollbar-thumb-neutral-900 px-1">
                 {folders.map((folder, index) => (
-                    <FolderItem key={index} path={folder} onDelete={() => {removeFolder(index)}}/>
+                    <FolderItem key={index} version={data} relativeFolder={folder} onDelete={() => {removeFolder(index)}}/>
                 ))}
             </ul>
             <div className="w-full h-12 rounded-md flex justify-center items-center cursor-pointer bg-light-main-color-1 dark:bg-main-color-1 hover:bg-light-main-color-3 hover:dark:bg-main-color-3" onClick={addFolder}>
@@ -106,17 +85,18 @@ export const ShareFoldersModal: ModalComponent<void, BSVersion> = ({ data }) =>
 }
 
 type FolderProps = {
-    path: string;
+    version: BSVersion;
+    relativeFolder: string;
     onDelete?: () => void;
 }
 
-const FolderItem = ({path, onDelete}: FolderProps) => {
+const FolderItem = ({version, relativeFolder, onDelete}: FolderProps) => {
 
-    const linker = FolderLinkerService.getInstance();
+    const linker = VersionFolderLinkerService.getInstance();
 
     const t = useTranslation();
 
-    const name = path.split("\\").at(-1);
+    const name = relativeFolder.split("\\").at(-1);
     const color = useThemeColor("first-color");
 
     const variants: Variants = { 
@@ -124,35 +104,43 @@ const FolderItem = ({path, onDelete}: FolderProps) => {
         tap: {rotate: 45}
     };
 
-    const pending = useObservable(linker.isPending(path));
-    const processing = useObservable(linker.isProcessing(path));
+    const pending = useObservable(linker.isPending(version, relativeFolder));
+    const processing = useObservable(linker.isProcessing(version, relativeFolder));
     const linkDisabled = pending || processing;
 
     const [linked, setLinked] = useState(false);
 
     useEffect(() => {
         loadFolderIsLinked();
-    }, [path]);
+    }, [version, relativeFolder]);
 
     const loadFolderIsLinked = () => {
-        linker.isFolderLinked(path).toPromise().then(setLinked);
+        linker.isVersionFolderLinked(version, relativeFolder).toPromise().then(setLinked);
     }
 
     const onClickLink = () => {
         if(linked){
-            return linker.unlinkFolder(path).toPromise().then(loadFolderIsLinked);
+            return linker.unlinkVersionFolder({
+                version,
+                relativeFolder,
+                type: VersionLinkerActionType.Unlink,
+            }).then(loadFolderIsLinked);
         }
-        return linker.linkFolder(path).toPromise().then(loadFolderIsLinked);
+        return linker.linkVersionFolder({
+            version,
+            relativeFolder,
+            type: VersionLinkerActionType.Link,
+        }).then(loadFolderIsLinked);
     }
 
-    const cancelLink = () => { 
-        linker.cancelFolder(path);
+    const cancelLink = () => {
+        linker.cancelAction(version, relativeFolder);
         loadFolderIsLinked();
     }
 
     return (
         <li className="w-full h-12 rounded-md shrink-0 flex flex-row items-center justify-between px-2 font-bold bg-light-main-color-1 dark:bg-main-color-1">
-            <span className="cursor-help" title={path}>{name}</span>
+            <span className="cursor-help" title={relativeFolder}>{name}</span>
             <div className="flex flex-row gap-1.5">
                 <Tippy placement="left" content={t(`modals.shared-folders.buttons.${linked ? "unlink-folder" : "link-folder"}`)} arrow={false}>
                     <LinkButton variants={variants} linked={linked} disabled={linkDisabled} whileHover="hover" whileTap="tap" className="p-0.5 h-7 shrink-0 aspect-square blur-0 cursor-pointer hover:brightness-75" onClick={onClickLink}/>

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

@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
 import { useObservable } from 'renderer/hooks/use-observable.hook';
 import { useThemeColor } from 'renderer/hooks/use-theme-color.hook';
 import { AudioPlayerService } from 'renderer/services/audio-player.service';
@@ -17,9 +17,17 @@ export default function TitleBar({template = "index.html"} : {template: AppWindo
     const audio = AudioPlayerService.getInstance();
 
     const volume = useObservable(audio.volume$, audio.volume);
-    const playing = useObservable(audio.playing$);
     const color = useThemeColor("first-color");
 
+    const [previewVersion, setPreviewVersion] = useState(null);
+
+    useEffect(() => {
+        ipcService.send<string>("current-version").then(res => {
+            if(res.data.toLocaleLowerCase().includes("alpha")){ return setPreviewVersion("ALPHA"); }
+            if(res.data.toLocaleLowerCase().includes("beta")){ return setPreviewVersion("BETA"); }
+        });
+    })
+
     const [maximized, setMaximized] = useState(false);
 
         const closeWindow = () => {
@@ -57,6 +65,7 @@ export default function TitleBar({template = "index.html"} : {template: AppWindo
                 <div id="drag-region" className='grow basis-0 h-full'>
                     <div id="window-title" className='pl-1'>
                         <span className='text-gray-800 dark:text-gray-100 font-bold text-xs italic'>BSManager</span>
+                        { previewVersion && <span className='bg-main-color-1 text-white dark:text-black dark:bg-white rounded-full ml-1 text-[10px] italic px-1 uppercase h-3.5 font-bold'>{previewVersion}</span> }
                     </div>
                 </div>
                 <div id="window-controls" className="h-full flex shrink-0 items-center">

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

@@ -17,6 +17,7 @@ import { useInView } from "framer-motion";
 import { ModalExitCode, ModalService } from "renderer/services/modale.service";
 import { ModsDisclaimerModal } from "renderer/components/modal/modal-types/mods-disclaimer-modal.component";
 import { OsDiagnosticService } from "renderer/services/os-diagnostic.service";
+import { lt } from "semver";
  
 export function ModsSlide({version, onDisclamerDecline}: {version: BSVersion, onDisclamerDecline: () => void}) {
 
@@ -68,7 +69,12 @@ export function ModsSlide({version, onDisclamerDecline}: {version: BSVersion, on
 
     const installMods = () => {
         if(installing){ return; }
-        modsManager.installMods(modsSelected, version).then(() => {
+        const modsToInstall = modsSelected.filter(mod => {
+            const corespondingMod = modsAvailable.get(mod.category).find(availabeMod => availabeMod._id === mod._id);
+            if(lt(corespondingMod.version, mod.version)){ return false; }
+            return true;
+        })
+        modsManager.installMods(modsToInstall, version).then(() => {
             loadMods();
         });
     }

src/renderer/index.tsx

@@ -2,12 +2,19 @@ import { createRoot } from 'react-dom/client';
 import { HashRouter } from 'react-router-dom';
 import 'tailwindcss/tailwind.css';
 import './index.css'
+import { IpcService } from './services/ipc.service';
 
 const launcherContainer = document.getElementById('launcher');
 const oneclickDownloadMapContainer = document.getElementById('oneclick-download-map');
 const oneclickDownloadPlaylistContainer = document.getElementById('oneclick-download-playlist');
 const oneclickDownloadModelContainer = document.getElementById('oneclick-download-model');
 
+const ipc = IpcService.getInstance();
+
+window.onerror = (...data) => {
+    ipc.sendLazy('log-error', {args: data});
+}
+
 if(launcherContainer){
     import("./windows/Launcher").then(reactWindow => {
         createRoot(launcherContainer).render(<reactWindow.default/>);

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

@@ -136,7 +136,7 @@ export function SettingsPage() {
       setShowSupporters(show => !show);
     }
     
-  const openSupportPage = () => linkOpener.open("https://mee6.gg/m/bsmanager");
+  const openSupportPage = () => linkOpener.open("https://www.patreon.com/bsmanager");
   const openGithub = () => linkOpener.open("https://github.com/Zagrios/bs-manager");
   const openReportBug = () => linkOpener.open("https://github.com/Zagrios/bs-manager/issues/new?assignees=Zagrios&labels=bug&template=-bug--bug-report.md&title=%5BBUG%5D+%3A+");
   const openRequestFeatures = () => linkOpener.open("https://github.com/Zagrios/bs-manager/issues/new?assignees=Zagrios&labels=enhancement&template=-feat---feature-request.md&title=%5BFEAT.%5D+%3A+");
@@ -282,7 +282,7 @@ export function SettingsPage() {
 
                 <SettingContainer title="pages.settings.patreon.title" description="pages.settings.patreon.description">
                     <div className="flex gap-2">
-                        <BsmButton disabled color="#ef4444" className="flex w-fit rounded-md h-8 px-2 font-bold py-1 whitespace-nowrap !text-white" text="pages.settings.patreon.buttons.support" withBar={false} onClick={openSupportPage}/>
+                        <BsmButton color="#ef4444" className="flex w-fit rounded-md h-8 px-2 font-bold py-1 whitespace-nowrap !text-white" text="pages.settings.patreon.buttons.support" withBar={false} onClick={openSupportPage}/>
                         <BsmButton className="flex w-fit rounded-md h-8 px-2 font-bold py-1 !text-white" withBar={false} text="pages.settings.patreon.buttons.supporters" color="#6c5ce7" onClick={toogleShowSupporters}/>
                     </div>
                     <SettingContainer className="mt-3" description="pages.settings.discord.description">

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

@@ -5,6 +5,7 @@ import { ModalExitCode, ModalService } from './modale.service';
 import { NotificationService } from './notification.service';
 import { ProgressBarService } from './progress-bar.service';
 import { EditVersionModal } from 'renderer/components/modal/modal-types/edit-version-modal.component';
+import { Observable } from 'rxjs';
 
 export class BSVersionManagerService {
 
@@ -113,4 +114,8 @@ export class BSVersionManagerService {
       })
    }
 
+   public getVersionPath(version: BSVersion): Observable<string>{
+        return this.ipcService.sendV2("get-version-full-path", {args: version});
+   }
+
 }

src/renderer/services/folder-linker.service.ts

@@ -1,185 +0,0 @@
-import { BehaviorSubject } from "rxjs";
-import { map, distinctUntilChanged, filter } from "rxjs/operators";
-import { from } from "rxjs";
-import { Observable } from "rxjs";
-import { IpcService } from "./ipc.service";
-import { ProgressBarService } from "./progress-bar.service";
-import { NotificationService } from "./notification.service";
-import { LinkOptions } from "main/services/folder-linker.service";
-
-export class FolderLinkerService {
-
-    private static instance: FolderLinkerService;
-
-    public static getInstance(): FolderLinkerService {
-        if (!FolderLinkerService.instance) {
-            FolderLinkerService.instance = new FolderLinkerService();
-        }
-        return FolderLinkerService.instance;
-    }
-
-    private readonly ipc: IpcService;
-    private readonly progress: ProgressBarService;
-    private readonly notification: NotificationService;
-
-    private readonly onLinkedListeners = new Map<string, () => void>();
-    private readonly onUnlinkedListeners = new Map<string, () => void>();
-    private readonly onRemovedFromQueueListeners = new Map<string, () => void>();
-
-    private readonly publicOnLinkedListeners = new Set<(folder: string) => void>();
-    private readonly publicOnUnlinkedListeners = new Set<(folder: string) => void>();
-
-    private readonly _currentAction$ = new BehaviorSubject<LinkAction>(null);
-    private readonly _queue$ = new BehaviorSubject<LinkAction[]>([]);
-
-    private constructor() {
-        this.ipc = IpcService.getInstance();
-        this.progress = ProgressBarService.getInstance();
-        this.notification = NotificationService.getInstance();
-
-        this.queue$.pipe(map(queue => !!queue.length), distinctUntilChanged(), filter(haveAction => haveAction)).subscribe(() => {
-            this.startQueue();
-        });
-    }
-
-    private async startQueue(): Promise<void>{
-
-        while(this._queue$.value.at(0)){
-
-            const toDo = this._queue$.value.at(0);
-
-            let progressOpened = false;
-
-            if(!this.progress.isVisible){
-                this.progress.showFake(.01, null, toDo.folder.split("\\").at(-1));
-                progressOpened = true;
-            }
-            
-            this._currentAction$.next(toDo);
-            await this.doAction(toDo).toPromise();
-
-            this.specialFolderNotification(toDo);
-
-            if(toDo.type === LinkActionType.Link){
-                this.onLinkedListeners.get(toDo.folder)?.();
-                this.publicOnLinkedListeners.forEach(listener => listener(toDo.folder));
-                this.onLinkedListeners.delete(toDo.folder);
-            }
-            else{
-                this.onUnlinkedListeners.get(toDo.folder)?.();
-                this.publicOnUnlinkedListeners.forEach(listener => listener(toDo.folder));
-                this.onUnlinkedListeners.delete(toDo.folder);
-            }
-
-            const newArr = [...this._queue$.value];
-            newArr.shift();
-            this._queue$.next(newArr);
-
-            if(progressOpened){
-                this.progress.hide(true);
-            }
-
-        }
-
-        this._currentAction$.next(null);
-    }
-
-    private specialFolderNotification(action: LinkAction): void{
-        if(action.type === LinkActionType.Link && action.folder.includes("UserData")){
-            this.notification.notifyInfo({
-                title: "notifications.shared-folder.info.userdata-backup-created.title",
-                desc: "notifications.shared-folder.info.userdata-backup-created.msg",
-                duration: 7000
-            });
-            return;
-        }
-    }
-
-    private doAction(action: LinkAction): Observable<void>{
-        return this.ipc.sendV2<void, {folder: string, options?: LinkOptions}>(action.type === LinkActionType.Link ? "link-folder" : "unlink-folder", { args: { folder: action.folder, options: action.options } });
-    }
-    
-    private addFolderToQueue(folder: string, type: LinkActionType, options: LinkOptions){
-        if(this._queue$.value.some(action => action.folder === folder)){ return; }
-        this._queue$.next([...this._queue$.value, {folder, type, options}]);
-    }
-
-    private removeFolderFromQueue(folder: string){
-        const queue = this._queue$.value;
-        const index = queue.findIndex(action => action.folder === folder);
-        if(index === -1){ return; }
-        this.onRemovedFromQueueListeners.get(folder)?.();
-        queue.splice(index, 1);
-        this._queue$.next(queue);
-    }
-
-    private onLinked(folder: string, callback: () => void){ this.onLinkedListeners.set(folder, callback); }
-    private onUnlinked(folder: string, callback: () => void){ this.onUnlinkedListeners.set(folder, callback); }
-    private onRemovedFromQueue(folder: string, callback: () => void){ this.onRemovedFromQueueListeners.set(folder, callback); }
-    
-    public isFolderLinked(path: string): Observable<boolean> { 
-        return this.ipc.sendV2<boolean>("is-folder-symlink", {args: path});
-    }
-
-    public linkFolders(...folders: string[]): Map<string, Observable<void>> {
-        return new Map(folders.map(folder => [folder, this.linkFolder(folder)]));
-    }
-
-    public linkFolder(folder: string, options: LinkOptions = {}): Observable<void> {
-        options.keepContents ??= true;
-        const promise = new Promise<void>(resolve => {
-            this.onLinked(folder, resolve);
-            this.onRemovedFromQueue(folder, resolve);
-        });
-
-        this.addFolderToQueue(folder, LinkActionType.Link, options);
-        return from(promise);
-    }
-
-    public unlinkFolders(...folders: string[]): Map<string, Observable<void>> {
-        return new Map(folders.map(folder => [folder, this.unlinkFolder(folder)]));
-    }
-
-    public unlinkFolder(folder: string, options: LinkOptions = {}): Observable<void> {
-        options.keepContents ??= true;
-        const promise = new Promise<void>(resolve => {
-            this.onUnlinked(folder, resolve);
-            this.onRemovedFromQueue(folder, resolve);
-        });
-
-        this.addFolderToQueue(folder, LinkActionType.Unlink, options);
-        return from(promise);
-    }
-
-    public cancelFolder(folder: string): void {
-        this.removeFolderFromQueue(folder);
-    }
-
-    public get queue$(): Observable<LinkAction[]> { return this._queue$.asObservable(); }
-    public get currentAction$(): Observable<LinkAction> { return this._currentAction$.asObservable(); }
-
-    public isPending(folder: string): Observable<boolean> {
-        return this.queue$.pipe(map(queue => queue.some(action => action.folder === folder), distinctUntilChanged()));
-    }
-
-    public isProcessing(folder: string): Observable<boolean> {
-        return this.currentAction$.pipe(distinctUntilChanged(), map(action => action?.folder === folder));
-    }
-
-    public onFolderLinked(callback: (folder: string) => void): void { this.publicOnLinkedListeners.add(callback); }
-    public removeOnFolderLinked(callback: (folder: string) => void): void { this.publicOnLinkedListeners.delete(callback); }
-    public onFolderUnlinked(callback: (folder: string) => void): void { this.publicOnUnlinkedListeners.add(callback); }
-    public removeOnFolderUnlinked(callback: (folder: string) => void): void { this.publicOnUnlinkedListeners.delete(callback); }
-
-}
-
-export interface LinkAction {
-    folder: string;
-    type: LinkActionType;
-    options?: LinkOptions;
-}
-
-export enum LinkActionType {
-    Link,
-    Unlink
-}

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

@@ -13,10 +13,13 @@ import { ConfigurationService } from "./configuration.service";
 import { ArchiveProgress } from "shared/models/archive.interface";
 import { map, last, catchError, distinctUntilChanged, mergeMap } from "rxjs/operators";
 import { ProgressionInterface } from "shared/models/progress-bar";
-import { FolderLinkerService } from "./folder-linker.service";
+import { VersionFolderLinkerService, VersionLinkerActionType } from "./version-folder-linker.service";
+import equal from "fast-deep-equal";
 
 export class MapsManagerService {
 
+    
+
     private static instance: MapsManagerService;
 
     public static getInstance(): MapsManagerService{
@@ -25,13 +28,14 @@ export class MapsManagerService {
     }
 
     public static readonly REMEMBER_CHOICE_DELETE_MAP_KEY = "not-confirm-delete-map"
+    public static readonly RELATIVE_MAPS_FOLDER = "Beat Saber_Data\\CustomLevels";
 
     private readonly ipcService: IpcService;
     private readonly modal: ModalService;
     private readonly progressBar: ProgressBarService;
     private readonly notifications: NotificationService;
     private readonly config: ConfigurationService;
-    private readonly linker: FolderLinkerService;
+    private readonly linker: VersionFolderLinkerService;
 
     private readonly lastLinkedVersion$: Subject<BSVersion> = new Subject();
     private readonly lastUnlinkedVersion$: Subject<BSVersion> = new Subject();
@@ -42,11 +46,7 @@ export class MapsManagerService {
         this.progressBar = ProgressBarService.getInstance();
         this.notifications = NotificationService.getInstance();
         this.config = ConfigurationService.getInstance();
-        this.linker = FolderLinkerService.getInstance();
-    }
-
-    private async getVersionMapsPath(version: BSVersion): Promise<string>{
-        return this.ipcService.sendV2<string>("get-version-maps-path", {args: version}).toPromise();
+        this.linker = VersionFolderLinkerService.getInstance();
     }
 
     public getMaps(version?: BSVersion): Observable<BsmLocalMapsProgress>{
@@ -54,30 +54,35 @@ export class MapsManagerService {
     }
 
     public async versionHaveMapsLinked(version: BSVersion): Promise<boolean>{
-        const versionMapsPath = await this.getVersionMapsPath(version);
-        return this.linker.isFolderLinked(versionMapsPath).toPromise();
+        return this.linker.isVersionFolderLinked(version, MapsManagerService.RELATIVE_MAPS_FOLDER).toPromise();
     }
 
-    public async linkVersion(version: BSVersion): Promise<void>{
+    public async linkVersion(version: BSVersion): Promise<boolean>{
 
         const modalRes = await this.modal.openModal(LinkMapsModal);
 
-        if(modalRes.exitCode !== ModalExitCode.COMPLETED){ return; }
+        if(modalRes.exitCode !== ModalExitCode.COMPLETED){ return Promise.resolve(false); }
 
-        const versionMapsPath = await this.getVersionMapsPath(version);
-
-        return this.linker.linkFolder(versionMapsPath, {keepContents: !!modalRes.data}).toPromise();
+        return this.linker.linkVersionFolder({
+            version,
+            type: VersionLinkerActionType.Link,
+            relativeFolder: MapsManagerService.RELATIVE_MAPS_FOLDER,
+            options: { keepContents: !!modalRes.data }
+        });
     }
 
-    public async unlinkVersion(version: BSVersion): Promise<void>{
+    public async unlinkVersion(version: BSVersion): Promise<boolean>{
 
         const modalRes = await this.modal.openModal(UnlinkMapsModal);
 
-        if(modalRes.exitCode !== ModalExitCode.COMPLETED){ return; }
+        if(modalRes.exitCode !== ModalExitCode.COMPLETED){ return Promise.resolve(false); }
 
-        const versionMapsPath = await this.getVersionMapsPath(version);
-
-        return this.linker.unlinkFolder(versionMapsPath, {keepContents: !!modalRes.data}).toPromise();
+        return this.linker.unlinkVersionFolder({
+            version,
+            type: VersionLinkerActionType.Unlink,
+            relativeFolder: MapsManagerService.RELATIVE_MAPS_FOLDER,
+            options: { keepContents: !!modalRes.data }
+        });
     }
 
     public async deleteMaps(maps: BsmLocalMap[], version?: BSVersion): Promise<boolean>{
@@ -155,8 +160,7 @@ export class MapsManagerService {
 
     public $mapsLinkingPending(version: BSVersion): Observable<boolean>{
         return this.linker.queue$.pipe(mergeMap(async queue => {
-            const versionMapsPath = await this.getVersionMapsPath(version);
-            return queue.some(q => q.folder.includes(versionMapsPath));
+            return queue.some(q => q.relativeFolder.includes(MapsManagerService.RELATIVE_MAPS_FOLDER) && equal(q.version, version));
         }), distinctUntilChanged());
     }
 

src/renderer/services/version-folder-linker.service.ts

@@ -0,0 +1,167 @@
+import { LinkOptions, UnlinkOptions } from "main/services/folder-linker.service";
+import { map, distinctUntilChanged, filter } from "rxjs/operators";
+import { BehaviorSubject, Observable } from "rxjs";
+import { BSVersion } from "shared/bs-version.interface";
+import { IpcService } from "./ipc.service";
+import { ProgressBarService } from "./progress-bar.service";
+
+export class VersionFolderLinkerService{
+
+    private static instance: VersionFolderLinkerService;
+
+    public static getInstance(): VersionFolderLinkerService{
+        if(!VersionFolderLinkerService.instance){ VersionFolderLinkerService.instance = new VersionFolderLinkerService() }
+        return VersionFolderLinkerService.instance;
+    }
+
+    private readonly ipcService: IpcService;
+    private readonly progress: ProgressBarService;
+
+    private readonly _queue$ = new BehaviorSubject<VersionLinkerAction[]>([]);
+
+    private readonly linkListeners = new Set<VersionLinkerActionListener>();
+    private readonly unlinkListeners = new Set<VersionLinkerActionListener>();
+
+    private constructor(){
+        this.ipcService = IpcService.getInstance();
+        this.progress = ProgressBarService.getInstance();
+
+        this.currentAction$.pipe(filter(action => !!action)).subscribe(action => this.processAction(action));
+    }
+
+    private async processAction(action: VersionLinkerAction){
+
+        let progressOpened = false;
+
+        if(!this.progress.isVisible){
+            this.progress.showFake(.01, null, action.relativeFolder.split("\\").at(-1));
+            progressOpened = true;
+        }
+
+        const linked = await this.doAction(action).toPromise();
+
+        // Spécial notification
+
+        if(action.type === VersionLinkerActionType.Link){
+            this.linkListeners.forEach(listener => listener(action, linked));
+        }
+        else{
+            this.unlinkListeners.forEach(listener => listener(action, linked));
+        }
+
+        if(progressOpened){
+            this.progress.hide(true);
+        }
+
+        const newArr = [...this._queue$.value];
+        newArr.shift();
+        this._queue$.next(newArr);
+
+    }
+
+    private doAction(action: VersionLinkerAction): Observable<boolean>{
+        return this.ipcService.sendV2<boolean, VersionLinkerAction>("link-version-folder-action", { args: action });
+    }
+
+    public linkVersionFolder(action: VersionLinkFolderAction): Promise<boolean>{
+        const promise = new Promise<boolean>((resolve) => {
+
+            const callBack: VersionLinkerActionListener = (performedAction, linked) => {
+                if(performedAction !== action){ return; }
+                this.removeVersionFolderLinkedListener(callBack);
+                resolve(linked);
+            }
+
+            this.onVersionFolderLinked(callBack);
+        });
+
+        this._queue$.next([...this._queue$.value, action]);
+
+        return promise;
+    }
+
+    public unlinkVersionFolder(action: VersionUnlinkFolderAction): Promise<boolean>{
+        const promise = new Promise<boolean>((resolve) => {
+
+            const callBack: VersionLinkerActionListener = (performedAction, linked) => {
+                if(performedAction !== action){ return; }
+                this.removeVersionFolderUnlinkedListener(callBack);
+                resolve(linked);
+            }
+
+            this.onVersionFolderUnlinked(callBack);
+        });
+
+        this._queue$.next([...this._queue$.value, action]);
+
+        return promise;
+    }
+
+    public onVersionFolderLinked(listener: VersionLinkerActionListener): void{
+        this.linkListeners.add(listener);
+    }
+
+    public removeVersionFolderLinkedListener(listener: VersionLinkerActionListener): void{
+        this.linkListeners.delete(listener);
+    }
+
+    public onVersionFolderUnlinked(listener: VersionLinkerActionListener): void{
+        this.unlinkListeners.add(listener);
+    }
+
+    public removeVersionFolderUnlinkedListener(listener: VersionLinkerActionListener): void{
+        this.unlinkListeners.delete(listener);
+    }
+
+    public cancelAction(version: BSVersion, relativeFolder: string): void{
+        this._queue$.next(this._queue$.value.filter(a => a.version !== version || a.relativeFolder !== relativeFolder));
+    }
+
+    public isVersionFolderLinked(version: BSVersion, relativeFolder: string): Observable<boolean>{
+        return this.ipcService.sendV2("is-version-folder-linked", { args: { version, relativeFolder } });
+    }
+
+    public isPending(version: BSVersion, relativeFolder: string): Observable<boolean> {
+        return this.queue$.pipe(map(queue => queue.length > 0 && queue.some(action => action.version === version && action.relativeFolder === relativeFolder), distinctUntilChanged()));
+    }
+
+    public isProcessing(version: BSVersion, relativeFolder: string): Observable<boolean> {
+        return this.currentAction$.pipe(map(action => ( action && action.version === version && action.relativeFolder === relativeFolder)));
+    }
+
+    public getLinkedFolders(version: BSVersion, options?: { relative?: boolean }): Observable<string[]>{
+        return this.ipcService.sendV2("get-linked-folders", { args: { version, options } });
+    }
+
+    public get currentAction$(): Observable<VersionLinkerAction>{
+        return this._queue$.pipe(map(actions => actions.at(0)), distinctUntilChanged());
+    }
+
+    public get queue$(): Observable<VersionLinkerAction[]>{
+        return this._queue$.asObservable();
+    }
+
+}
+
+export const enum VersionLinkerActionType {
+    Link = "link",
+    Unlink = "unlink"
+}
+
+export interface VersionLinkerAction {
+    version: BSVersion;
+    relativeFolder: string;
+    type: VersionLinkerActionType
+    options?: LinkOptions
+}
+
+export interface VersionLinkFolderAction extends VersionLinkerAction {
+    type: VersionLinkerActionType.Link
+}
+
+export interface VersionUnlinkFolderAction extends VersionLinkerAction {
+    type: VersionLinkerActionType.Unlink
+    options?: UnlinkOptions
+}
+
+export type VersionLinkerActionListener = (action: VersionLinkerAction, linked: boolean) => void;