Expand package installer interface with stubbed functions and add capability reporting

src/installers/BepInExInstaller.ts

@@ -1,4 +1,4 @@
-import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import { InstallArgs, InstallerCapability, PackageInstaller } from "./PackageInstaller";
 import path from "path";
 import FsProvider from "../providers/generic/file/FsProvider";
 import { MODLOADER_PACKAGES } from "../r2mm/installing/profile_installers/ModLoaderVariantRecord";
@@ -7,6 +7,15 @@ import { PackageLoader } from "../model/installing/PackageLoader";
 const basePackageFiles = ["manifest.json", "readme.md", "icon.png"];
 
 export class BepInExInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     /**
      * Handles installation of BepInEx
      */
@@ -39,4 +48,16 @@ export class BepInExInstaller extends PackageInstaller {
             }
         }
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }

src/installers/GodotMLInstaller.ts

@@ -1,8 +1,17 @@
-import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import { InstallArgs, InstallerCapability, PackageInstaller } from "./PackageInstaller";
 import path from "path";
 import FsProvider from "../providers/generic/file/FsProvider";
 
 export class GodotMLInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     /**
      * Handles installation of GodotML
      */
@@ -20,4 +29,16 @@ export class GodotMLInstaller extends PackageInstaller {
             await fs.copyFolder(copyFrom, copyTo);
         }
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }

src/installers/InstallRuleInstaller.ts

@@ -1,4 +1,4 @@
-import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import { InstallArgs, InstallerCapability, PackageInstaller } from "./PackageInstaller";
 import Profile from "../model/Profile";
 import FsProvider from "../providers/generic/file/FsProvider";
 import path from "path";
@@ -223,6 +223,15 @@ export class InstallRuleInstaller extends PackageInstaller {
         this.rule = rules;
     }
 
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     /**
      * Handles installation of packages according to the install rules defined
      * for it.
@@ -267,4 +276,16 @@ export class InstallRuleInstaller extends PackageInstaller {
         }
         return Promise.resolve(undefined);
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }

src/installers/LovelyInstaller.ts

@@ -1,4 +1,4 @@
-import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import { InstallArgs, InstallerCapability, PackageInstaller } from "./PackageInstaller";
 import { InstallRuleInstaller, addToStateFile } from "./InstallRuleInstaller";
 import FsProvider from "../providers/generic/file/FsProvider";
 import FileUtils from "../utils/FileUtils";
@@ -7,6 +7,15 @@ import R2Error from "../model/errors/R2Error";
 import path from "path";
 
 export class LovelyInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     async install(args: InstallArgs) {
         const {
             mod,
@@ -43,9 +52,30 @@ export class LovelyInstaller extends PackageInstaller {
 
         await addToStateFile(mod, fileRelocations, profile);
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }
 
 export class LovelyPluginInstaller extends PackageInstaller {
+     async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     async install(args: InstallArgs) {
         const {
             mod,
@@ -63,7 +93,7 @@ export class LovelyPluginInstaller extends PackageInstaller {
         if (srcTree instanceof R2Error) {
             throw R2Error;
         }
- 
+
         const srcFiles = srcTree.getRecursiveFiles();
         for (const srcFile of srcFiles) {
             const relFile = srcFile.replace(packagePath, "");
@@ -77,4 +107,16 @@ export class LovelyPluginInstaller extends PackageInstaller {
 
         await addToStateFile(mod, fileRelocations, profile);
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }

src/installers/MelonLoaderInstaller.ts

@@ -1,10 +1,19 @@
-import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import { InstallArgs, InstallerCapability, PackageInstaller } from "./PackageInstaller";
 import FsProvider from "../providers/generic/file/FsProvider";
 import path from "path";
 
 const basePackageFiles = ["manifest.json", "readme.md", "icon.png"];
 
 export class MelonLoaderInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     /**
      * Handles installation of MelonLoader
      */
@@ -21,4 +30,16 @@ export class MelonLoaderInstaller extends PackageInstaller {
             }
         }
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }

src/installers/NorthstarInstaller.ts

@@ -1,4 +1,4 @@
-import { InstallArgs, PackageInstaller } from './PackageInstaller';
+import { InstallArgs, InstallerCapability, PackageInstaller } from './PackageInstaller';
 import path from 'path';
 import FsProvider from '../providers/generic/file/FsProvider';
 import { MODLOADER_PACKAGES } from '../r2mm/installing/profile_installers/ModLoaderVariantRecord';
@@ -7,6 +7,15 @@ import { PackageLoader } from '../model/installing/PackageLoader';
 const basePackageFiles = ["manifest.json", "readme.md", "icon.png"];
 
 export class NorthstarInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     /**
      * Handles installation of Northstar
      */
@@ -39,4 +48,16 @@ export class NorthstarInstaller extends PackageInstaller {
             }
         }
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }

src/installers/PackageInstaller.ts

@@ -8,9 +8,18 @@ export type InstallArgs = {
     packagePath: string;
 };
 
+export class InstallerCapability {
+    install: boolean = false;
+    uninstall: boolean = false;
+    enable: boolean = false;
+    disable: boolean = false;
+}
+
 
 export abstract class PackageInstaller {
+    abstract capability(): Promise<InstallerCapability>;
     abstract install(args: InstallArgs): Promise<void>;
-    // abstract disable(args: InstallArgs): Promise<void>; // TODO: Implement
-    // abstract uninstall(): Promise<void>;  // TODO: Implement
+    abstract uninstall(args: InstallArgs): Promise<void>;
+    abstract enable(args: InstallArgs): Promise<void>;
+    abstract disable(args: InstallArgs): Promise<void>;
 }

src/installers/ReturnOfModdingInstaller.ts

@@ -1,4 +1,4 @@
-import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import { InstallArgs, InstallerCapability, PackageInstaller } from "./PackageInstaller";
 import path from "path";
 import FsProvider from "../providers/generic/file/FsProvider";
 import { MODLOADER_PACKAGES } from "../r2mm/installing/profile_installers/ModLoaderVariantRecord";
@@ -7,6 +7,15 @@ import { PackageLoader } from "../model/installing/PackageLoader";
 const basePackageFiles = ["manifest.json", "readme.md", "icon.png"];
 
 export class ReturnOfModdingInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     /**
      * Handles installation of BepInEx
      */
@@ -39,4 +48,16 @@ export class ReturnOfModdingInstaller extends PackageInstaller {
             }
         }
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }

src/installers/ShimloaderInstaller.ts

@@ -1,4 +1,4 @@
-import { InstallArgs, PackageInstaller } from "./PackageInstaller";
+import { InstallArgs, InstallerCapability, PackageInstaller } from "./PackageInstaller";
 import path from "path";
 import FsProvider from "../providers/generic/file/FsProvider";
 import FileTree from "../model/file/FileTree";
@@ -7,6 +7,15 @@ import R2Error from "../model/errors/R2Error";
 import { InstallRuleInstaller } from "./InstallRuleInstaller";
 
 export class ShimloaderInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     /**
      * Handle installation of unreal-shimloader
      */
@@ -53,9 +62,30 @@ export class ShimloaderInstaller extends PackageInstaller {
             await fs.mkdirs(configDir);
         }
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }
 
 export class ShimloaderPluginInstaller extends PackageInstaller {
+    async capability(): Promise<InstallerCapability> {
+        return {
+            install: true,
+            uninstall: false,
+            enable: false,
+            disable: false,
+        }
+    }
+
     readonly installer = new InstallRuleInstaller({
         gameName: "none" as any,  // This isn't acutally used for actual installation but needs some value
         rules: [
@@ -84,4 +114,16 @@ export class ShimloaderPluginInstaller extends PackageInstaller {
     async install(args: InstallArgs) {
         await this.installer.install(args);
     }
+
+    async uninstall(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async enable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+
+    async disable(args: InstallArgs): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }