Merge branch 'develop' of github.com:moonlight-mod/moonlight into develop

packages/browser/src/index.ts

···
 import { getExtensions } from "@moonlight-mod/core/extension";
 import { loadExtensions } from "@moonlight-mod/core/extension/loader";
 import { MoonlightBranch, MoonlightNode } from "@moonlight-mod/types";
+import { getConfig, getConfigOption, getManifest, setConfigOption } from "@moonlight-mod/core/util/config";
 import { IndexedDB } from "@zenfs/dom";
 import { configure } from "@zenfs/core";
 import * as fs from "@zenfs/core/promises";
···
   };
 
   // Actual loading begins here
-  const config = await readConfig();
+  let config = await readConfig();
   initLogger(config);
 
   const extensions = await getExtensions();
   const processedExtensions = await loadExtensions(extensions);
 
-  function getConfig(ext: string) {
-    const val = config.extensions[ext];
-    if (val == null || typeof val === "boolean") return undefined;
-    return val.config;
-  }
-
   const moonlightNode: MoonlightNode = {
-    config,
+    get config() {
+      return config;
+    },
     extensions,
     processedExtensions,
     nativesCache: {},
···
     version: MOONLIGHT_VERSION,
     branch: MOONLIGHT_BRANCH as MoonlightBranch,
 
-    getConfig,
-    getConfigOption: <T>(ext: string, name: string) => {
-      const config = getConfig(ext);
-      if (config == null) return undefined;
-      const option = config[name];
-      if (option == null) return undefined;
-      return option as T;
+    getConfig(ext) {
+      return getConfig(ext, config);
+    },
+    getConfigOption(ext, name) {
+      const manifest = getManifest(extensions, ext);
+      return getConfigOption(ext, name, config, manifest);
     },
+    setConfigOption(ext, name, value) {
+      setConfigOption(config, ext, name, value);
+      this.writeConfig(config);
+    },
+
     getNatives: () => {},
     getLogger: (id: string) => {
       return new Logger(id);
···
       return `/extensions/${ext}`;
     },
 
-    writeConfig
+    async writeConfig(newConfig) {
+      await writeConfig(newConfig);
+      config = newConfig;
+    }
   };
 
   Object.assign(window, {

packages/core-extensions/src/moonbase/native.ts

···
     async deleteExtension(id) {
       const dir = moonlightNode.getExtensionDir(id);
       await moonlightNodeSandboxed.fs.rmdir(dir);
-    },
-
-    getExtensionConfig(id, key) {
-      const config = moonlightNode.config.extensions[id];
-      if (typeof config === "object") {
-        return config.config?.[key];
-      }
-
-      return undefined;
     }
   };
 }

packages/core-extensions/src/moonbase/types.ts

···
   fetchRepositories(repos: string[]): Promise<Record<string, RepositoryManifest[]>>;
   installExtension(manifest: RepositoryManifest, url: string, repo: string): Promise<void>;
   deleteExtension(id: string): Promise<void>;
-  getExtensionConfig(id: string, key: string): any;
 };
 
 export type RepositoryManifest = ExtensionManifest & {

packages/core-extensions/src/moonbase/webpackModules/stores.ts

···
 import { mainRepo } from "@moonlight-mod/types/constants";
 import { checkExtensionCompat, ExtensionCompat } from "@moonlight-mod/core/extension/loader";
 import { CustomComponent } from "@moonlight-mod/types/coreExtensions/moonbase";
+import { getConfigOption, setConfigOption } from "@moonlight-mod/core/util/config";
 
 const logger = moonlight.getLogger("moonbase");
 
···
 
   getExtensionConfig<T>(uniqueId: number, key: string): T | undefined {
     const ext = this.getExtension(uniqueId);
-    const defaultValue = ext.manifest.settings?.[key]?.default;
-    const clonedDefaultValue = this.clone(defaultValue);
-    const cfg = this.config.extensions[ext.id];
-
-    if (cfg == null || typeof cfg === "boolean") return clonedDefaultValue;
-    return cfg.config?.[key] ?? clonedDefaultValue;
+    return getConfigOption(ext.id, key, this.config, ext.manifest);
   }
 
   getExtensionConfigRaw<T>(id: string, key: string, defaultValue: T | undefined): T | undefined {
     const cfg = this.config.extensions[id];
-
     if (cfg == null || typeof cfg === "boolean") return defaultValue;
     return cfg.config?.[key] ?? defaultValue;
   }
···
   }
 
   setExtensionConfig(id: string, key: string, value: any) {
-    const oldConfig = this.config.extensions[id];
-    const newConfig =
-      typeof oldConfig === "boolean"
-        ? {
-            enabled: oldConfig,
-            config: { [key]: value }
-          }
-        : {
-            ...oldConfig,
-            config: { ...(oldConfig?.config ?? {}), [key]: value }
-          };
-
-    this.config.extensions[id] = newConfig;
+    setConfigOption(this.config, id, key, value);
     this.modified = this.isModified();
     this.emitChange();
   }

packages/core/src/util/config.ts

···
+import type { Config, DetectedExtension, ExtensionManifest } from "@moonlight-mod/types";
+
+export function getManifest(extensions: DetectedExtension[], ext: string) {
+  return extensions.find((x) => x.id === ext)?.manifest;
+}
+
+export function getConfig(ext: string, config: Config) {
+  const val = config.extensions[ext];
+  if (val == null || typeof val === "boolean") return undefined;
+  return val.config;
+}
+
+export function getConfigOption<T>(
+  ext: string,
+  key: string,
+  config: Config,
+  manifest?: ExtensionManifest
+): T | undefined {
+  const defaultValue: T | undefined = structuredClone(manifest?.settings?.[key]?.default);
+  const cfg = getConfig(ext, config);
+  if (cfg == null || typeof cfg === "boolean") return defaultValue;
+  return cfg?.[key] ?? defaultValue;
+}
+
+export function setConfigOption<T>(config: Config, ext: string, key: string, value: T) {
+  const oldConfig = config.extensions[ext];
+  const newConfig =
+    typeof oldConfig === "boolean"
+      ? {
+          enabled: oldConfig,
+          config: { [key]: value }
+        }
+      : {
+          ...oldConfig,
+          config: { ...(oldConfig?.config ?? {}), [key]: value }
+        };
+
+  config.extensions[ext] = newConfig;
+}

packages/node-preload/src/index.ts

···
 import { loadExtensions, loadProcessedExtensions } from "@moonlight-mod/core/extension/loader";
 import createFS from "@moonlight-mod/core/fs";
 import { registerCors, registerBlocked, getDynamicCors } from "@moonlight-mod/core/cors";
+import { getConfig, getConfigOption, getManifest, setConfigOption } from "@moonlight-mod/core/util/config";
 
 let initialized = false;
 
···
     }
   };
 
-  const config = await readConfig();
+  let config = await readConfig();
   initLogger(config);
   const extensions = await getExtensions();
   const processedExtensions = await loadExtensions(extensions);
   const moonlightDir = await getMoonlightDir();
   const extensionsPath = await getExtensionsPath();
-
-  function getConfig(ext: string) {
-    const val = config.extensions[ext];
-    if (val == null || typeof val === "boolean") return undefined;
-    return val.config;
-  }
 
   global.moonlightNode = {
-    config,
+    get config() {
+      return config;
+    },
     extensions,
     processedExtensions,
     nativesCache: {},
···
     version: MOONLIGHT_VERSION,
     branch: MOONLIGHT_BRANCH as MoonlightBranch,
 
-    getConfig,
-    getConfigOption: <T>(ext: string, name: string) => {
-      const config = getConfig(ext);
-      if (config == null) return undefined;
-      const option = config[name];
-      if (option == null) return undefined;
-      return option as T;
+    getConfig(ext) {
+      return getConfig(ext, config);
+    },
+    getConfigOption(ext, name) {
+      const manifest = getManifest(extensions, ext);
+      return getConfigOption(ext, name, config, manifest);
     },
+    setConfigOption(ext, name, value) {
+      setConfigOption(config, ext, name, value);
+      this.writeConfig(config);
+    },
+
     getNatives: (ext: string) => global.moonlightNode.nativesCache[ext],
     getLogger: (id: string) => {
       return new Logger(id);
···
     getExtensionDir: (ext: string) => {
       return path.join(extensionsPath, ext);
     },
-    writeConfig
+    async writeConfig(newConfig) {
+      await writeConfig(newConfig);
+      config = newConfig;
+    }
   };
 
   await loadProcessedExtensions(processedExtensions);

packages/types/src/globals.ts

···
 
   getConfig: (ext: string) => ConfigExtension["config"];
   getConfigOption: <T>(ext: string, name: string) => T | undefined;
+  setConfigOption: <T>(ext: string, name: string, value: T) => void;
+
   getNatives: (ext: string) => any | undefined;
   getLogger: (id: string) => Logger;
 
···
   version: string;
   branch: MoonlightBranch;
 
-  getConfig: (ext: string) => ConfigExtension["config"];
-  getConfigOption: <T>(ext: string, name: string) => T | undefined;
+  // Re-exports for ease of use
+  getConfig: MoonlightNode["getConfig"];
+  getConfigOption: MoonlightNode["getConfigOption"];
+  setConfigOption: MoonlightNode["setConfigOption"];
+
   getNatives: (ext: string) => any | undefined;
   getLogger: (id: string) => Logger;
   lunast: LunAST;

packages/web-preload/src/index.ts

···
 
     getConfig: moonlightNode.getConfig.bind(moonlightNode),
     getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),
+    setConfigOption: moonlightNode.setConfigOption.bind(moonlightNode),
+
     getNatives: moonlightNode.getNatives.bind(moonlightNode),
     getLogger(id) {
       return new Logger(id);