commit 7795e4c1d353da90dd0381f95d4978cd4c6cb1a3 · notnite.com/moonlight

+20 -16

packages/browser/src/index.ts

···

       4
       4
        
       import { getExtensions } from "@moonlight-mod/core/extension";

     

       5
       5
        
       import { loadExtensions } from "@moonlight-mod/core/extension/loader";

     

       6
       6
        
       import { MoonlightBranch, MoonlightNode } from "@moonlight-mod/types";

     

       7
       7
       +
       import { getConfig, getConfigOption, getManifest, setConfigOption } from "@moonlight-mod/core/util/config";

     

       7
       8
        
       import { IndexedDB } from "@zenfs/dom";

     

       8
       9
        
       import { configure } from "@zenfs/core";

     

       9
       10
        
       import * as fs from "@zenfs/core/promises";

     
···

       99
       100
        
         };

     

       100
       101
        
       

     

       101
       102
        
         // Actual loading begins here

     

       102
       102
       -
         const config = await readConfig();

     

       103
       103
       +
         let config = await readConfig();

     

       103
       104
        
         initLogger(config);

     

       104
       105
        
       

     

       105
       106
        
         const extensions = await getExtensions();

     

       106
       107
        
         const processedExtensions = await loadExtensions(extensions);

     

       107
       108
        
       

     

       108
       108
       -
         function getConfig(ext: string) {

     

       109
       109
       -
           const val = config.extensions[ext];

     

       110
       110
       -
           if (val == null || typeof val === "boolean") return undefined;

     

       111
       111
       -
           return val.config;

     

       112
       112
       -
         }

     

       113
       113
       -
       

     

       114
       109
        
         const moonlightNode: MoonlightNode = {

     

       115
       115
       -
           config,

     

       110
       110
       +
           get config() {

     

       111
       111
       +
             return config;

     

       112
       112
       +
           },

     

       116
       113
        
           extensions,

     

       117
       114
        
           processedExtensions,

     

       118
       115
        
           nativesCache: {},

     
···

       121
       118
        
           version: MOONLIGHT_VERSION,

     

       122
       119
        
           branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       123
       120
        
       

     

       124
       124
       -
           getConfig,

     

       125
       125
       -
           getConfigOption: <T>(ext: string, name: string) => {

     

       126
       126
       -
             const config = getConfig(ext);

     

       127
       127
       -
             if (config == null) return undefined;

     

       128
       128
       -
             const option = config[name];

     

       129
       129
       -
             if (option == null) return undefined;

     

       130
       130
       -
             return option as T;

     

       121
       121
       +
           getConfig(ext) {

     

       122
       122
       +
             return getConfig(ext, config);

     

       123
       123
       +
           },

     

       124
       124
       +
           getConfigOption(ext, name) {

     

       125
       125
       +
             const manifest = getManifest(extensions, ext);

     

       126
       126
       +
             return getConfigOption(ext, name, config, manifest);

     

       131
       127
        
           },

     

       128
       128
       +
           setConfigOption(ext, name, value) {

     

       129
       129
       +
             setConfigOption(config, ext, name, value);

     

       130
       130
       +
             this.writeConfig(config);

     

       131
       131
       +
           },

     

       132
       132
       +
       

     

       132
       133
        
           getNatives: () => {},

     

       133
       134
        
           getLogger: (id: string) => {

     

       134
       135
        
             return new Logger(id);

     
···

       141
       142
        
             return `/extensions/${ext}`;

     

       142
       143
        
           },

     

       143
       144
        
       

     

       144
       144
       -
           writeConfig

     

       145
       145
       +
           async writeConfig(newConfig) {

     

       146
       146
       +
             await writeConfig(newConfig);

     

       147
       147
       +
             config = newConfig;

     

       148
       148
       +
           }

     

       145
       149
        
         };

     

       146
       150
        
       

     

       147
       151
        
         Object.assign(window, {

-9

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

···

       178
       178
        
           async deleteExtension(id) {

     

       179
       179
        
             const dir = moonlightNode.getExtensionDir(id);

     

       180
       180
        
             await moonlightNodeSandboxed.fs.rmdir(dir);

     

       181
       181
       -
           },

     

       182
       182
       -
       

     

       183
       183
       -
           getExtensionConfig(id, key) {

     

       184
       184
       -
             const config = moonlightNode.config.extensions[id];

     

       185
       185
       -
             if (typeof config === "object") {

     

       186
       186
       -
               return config.config?.[key];

     

       187
       187
       -
             }

     

       188
       188
       -
       

     

       189
       189
       -
             return undefined;

     

       190
       181
        
           }

     

       191
       182
        
         };

     

       192
       183
        
       }

-1

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

···

       8
       8
        
         fetchRepositories(repos: string[]): Promise<Record<string, RepositoryManifest[]>>;

     

       9
       9
        
         installExtension(manifest: RepositoryManifest, url: string, repo: string): Promise<void>;

     

       10
       10
        
         deleteExtension(id: string): Promise<void>;

     

       11
       11
       -
         getExtensionConfig(id: string, key: string): any;

     

       12
       11
        
       };

     

       13
       12
        
       

     

       14
       13
        
       export type RepositoryManifest = ExtensionManifest & {

+3 -20

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

···

       6
       6
        
       import { mainRepo } from "@moonlight-mod/types/constants";

     

       7
       7
        
       import { checkExtensionCompat, ExtensionCompat } from "@moonlight-mod/core/extension/loader";

     

       8
       8
        
       import { CustomComponent } from "@moonlight-mod/types/coreExtensions/moonbase";

     

       9
       9
       +
       import { getConfigOption, setConfigOption } from "@moonlight-mod/core/util/config";

     

       9
       10
        
       

     

       10
       11
        
       const logger = moonlight.getLogger("moonbase");

     

       11
       12
        
       

     
···

       191
       192
        
       

     

       192
       193
        
         getExtensionConfig<T>(uniqueId: number, key: string): T | undefined {

     

       193
       194
        
           const ext = this.getExtension(uniqueId);

     

       194
       194
       -
           const defaultValue = ext.manifest.settings?.[key]?.default;

     

       195
       195
       -
           const clonedDefaultValue = this.clone(defaultValue);

     

       196
       196
       -
           const cfg = this.config.extensions[ext.id];

     

       197
       197
       -
       

     

       198
       198
       -
           if (cfg == null || typeof cfg === "boolean") return clonedDefaultValue;

     

       199
       199
       -
           return cfg.config?.[key] ?? clonedDefaultValue;

     

       195
       195
       +
           return getConfigOption(ext.id, key, this.config, ext.manifest);

     

       200
       196
        
         }

     

       201
       197
        
       

     

       202
       198
        
         getExtensionConfigRaw<T>(id: string, key: string, defaultValue: T | undefined): T | undefined {

     

       203
       199
        
           const cfg = this.config.extensions[id];

     

       204
       204
       -
       

     

       205
       200
        
           if (cfg == null || typeof cfg === "boolean") return defaultValue;

     

       206
       201
        
           return cfg.config?.[key] ?? defaultValue;

     

       207
       202
        
         }

     
···

       217
       212
        
         }

     

       218
       213
        
       

     

       219
       214
        
         setExtensionConfig(id: string, key: string, value: any) {

     

       220
       220
       -
           const oldConfig = this.config.extensions[id];

     

       221
       221
       -
           const newConfig =

     

       222
       222
       -
             typeof oldConfig === "boolean"

     

       223
       223
       -
               ? {

     

       224
       224
       -
                   enabled: oldConfig,

     

       225
       225
       -
                   config: { [key]: value }

     

       226
       226
       -
                 }

     

       227
       227
       -
               : {

     

       228
       228
       -
                   ...oldConfig,

     

       229
       229
       -
                   config: { ...(oldConfig?.config ?? {}), [key]: value }

     

       230
       230
       -
                 };

     

       231
       231
       -
       

     

       232
       232
       -
           this.config.extensions[id] = newConfig;

     

       215
       215
       +
           setConfigOption(this.config, id, key, value);

     

       233
       216
        
           this.modified = this.isModified();

     

       234
       217
        
           this.emitChange();

     

       235
       218
        
         }

+39

packages/core/src/util/config.ts

···

       1
       1
       +
       import type { Config, DetectedExtension, ExtensionManifest } from "@moonlight-mod/types";

     

       2
       2
       +
       

     

       3
       3
       +
       export function getManifest(extensions: DetectedExtension[], ext: string) {

     

       4
       4
       +
         return extensions.find((x) => x.id === ext)?.manifest;

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       export function getConfig(ext: string, config: Config) {

     

       8
       8
       +
         const val = config.extensions[ext];

     

       9
       9
       +
         if (val == null || typeof val === "boolean") return undefined;

     

       10
       10
       +
         return val.config;

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       export function getConfigOption<T>(

     

       14
       14
       +
         ext: string,

     

       15
       15
       +
         key: string,

     

       16
       16
       +
         config: Config,

     

       17
       17
       +
         manifest?: ExtensionManifest

     

       18
       18
       +
       ): T | undefined {

     

       19
       19
       +
         const defaultValue: T | undefined = structuredClone(manifest?.settings?.[key]?.default);

     

       20
       20
       +
         const cfg = getConfig(ext, config);

     

       21
       21
       +
         if (cfg == null || typeof cfg === "boolean") return defaultValue;

     

       22
       22
       +
         return cfg?.[key] ?? defaultValue;

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       export function setConfigOption<T>(config: Config, ext: string, key: string, value: T) {

     

       26
       26
       +
         const oldConfig = config.extensions[ext];

     

       27
       27
       +
         const newConfig =

     

       28
       28
       +
           typeof oldConfig === "boolean"

     

       29
       29
       +
             ? {

     

       30
       30
       +
                 enabled: oldConfig,

     

       31
       31
       +
                 config: { [key]: value }

     

       32
       32
       +
               }

     

       33
       33
       +
             : {

     

       34
       34
       +
                 ...oldConfig,

     

       35
       35
       +
                 config: { ...(oldConfig?.config ?? {}), [key]: value }

     

       36
       36
       +
               };

     

       37
       37
       +
       

     

       38
       38
       +
         config.extensions[ext] = newConfig;

     

       39
       39
       +
       }

+20 -16

packages/node-preload/src/index.ts

···

       10
       10
        
       import { loadExtensions, loadProcessedExtensions } from "@moonlight-mod/core/extension/loader";

     

       11
       11
        
       import createFS from "@moonlight-mod/core/fs";

     

       12
       12
        
       import { registerCors, registerBlocked, getDynamicCors } from "@moonlight-mod/core/cors";

     

       13
       13
       +
       import { getConfig, getConfigOption, getManifest, setConfigOption } from "@moonlight-mod/core/util/config";

     

       13
       14
        
       

     

       14
       15
        
       let initialized = false;

     

       15
       16
        
       

     
···

       32
       33
        
           }

     

       33
       34
        
         };

     

       34
       35
        
       

     

       35
       35
       -
         const config = await readConfig();

     

       36
       36
       +
         let config = await readConfig();

     

       36
       37
        
         initLogger(config);

     

       37
       38
        
         const extensions = await getExtensions();

     

       38
       39
        
         const processedExtensions = await loadExtensions(extensions);

     

       39
       40
        
         const moonlightDir = await getMoonlightDir();

     

       40
       41
        
         const extensionsPath = await getExtensionsPath();

     

       41
       41
       -
       

     

       42
       42
       -
         function getConfig(ext: string) {

     

       43
       43
       -
           const val = config.extensions[ext];

     

       44
       44
       -
           if (val == null || typeof val === "boolean") return undefined;

     

       45
       45
       -
           return val.config;

     

       46
       46
       -
         }

     

       47
       42
        
       

     

       48
       43
        
         global.moonlightNode = {

     

       49
       49
       -
           config,

     

       44
       44
       +
           get config() {

     

       45
       45
       +
             return config;

     

       46
       46
       +
           },

     

       50
       47
        
           extensions,

     

       51
       48
        
           processedExtensions,

     

       52
       49
        
           nativesCache: {},

     
···

       55
       52
        
           version: MOONLIGHT_VERSION,

     

       56
       53
        
           branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       57
       54
        
       

     

       58
       58
       -
           getConfig,

     

       59
       59
       -
           getConfigOption: <T>(ext: string, name: string) => {

     

       60
       60
       -
             const config = getConfig(ext);

     

       61
       61
       -
             if (config == null) return undefined;

     

       62
       62
       -
             const option = config[name];

     

       63
       63
       -
             if (option == null) return undefined;

     

       64
       64
       -
             return option as T;

     

       55
       55
       +
           getConfig(ext) {

     

       56
       56
       +
             return getConfig(ext, config);

     

       57
       57
       +
           },

     

       58
       58
       +
           getConfigOption(ext, name) {

     

       59
       59
       +
             const manifest = getManifest(extensions, ext);

     

       60
       60
       +
             return getConfigOption(ext, name, config, manifest);

     

       65
       61
        
           },

     

       62
       62
       +
           setConfigOption(ext, name, value) {

     

       63
       63
       +
             setConfigOption(config, ext, name, value);

     

       64
       64
       +
             this.writeConfig(config);

     

       65
       65
       +
           },

     

       66
       66
       +
       

     

       66
       67
        
           getNatives: (ext: string) => global.moonlightNode.nativesCache[ext],

     

       67
       68
        
           getLogger: (id: string) => {

     

       68
       69
        
             return new Logger(id);

     
···

       74
       75
        
           getExtensionDir: (ext: string) => {

     

       75
       76
        
             return path.join(extensionsPath, ext);

     

       76
       77
        
           },

     

       77
       77
       -
           writeConfig

     

       78
       78
       +
           async writeConfig(newConfig) {

     

       79
       79
       +
             await writeConfig(newConfig);

     

       80
       80
       +
             config = newConfig;

     

       81
       81
       +
           }

     

       78
       82
        
         };

     

       79
       83
        
       

     

       80
       84
        
         await loadProcessedExtensions(processedExtensions);

+7 -2

packages/types/src/globals.ts

···

       34
       34
        
       

     

       35
       35
        
         getConfig: (ext: string) => ConfigExtension["config"];

     

       36
       36
        
         getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       37
       37
       +
         setConfigOption: <T>(ext: string, name: string, value: T) => void;

     

       38
       38
       +
       

     

       37
       39
        
         getNatives: (ext: string) => any | undefined;

     

       38
       40
        
         getLogger: (id: string) => Logger;

     

       39
       41
        
       

     
···

       63
       65
        
         version: string;

     

       64
       66
        
         branch: MoonlightBranch;

     

       65
       67
        
       

     

       66
       66
       -
         getConfig: (ext: string) => ConfigExtension["config"];

     

       67
       67
       -
         getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       68
       68
       +
         // Re-exports for ease of use

     

       69
       69
       +
         getConfig: MoonlightNode["getConfig"];

     

       70
       70
       +
         getConfigOption: MoonlightNode["getConfigOption"];

     

       71
       71
       +
         setConfigOption: MoonlightNode["setConfigOption"];

     

       72
       72
       +
       

     

       68
       73
        
         getNatives: (ext: string) => any | undefined;

     

       69
       74
        
         getLogger: (id: string) => Logger;

     

       70
       75
        
         lunast: LunAST;

+2

packages/web-preload/src/index.ts

···

       30
       30
        
       

     

       31
       31
        
           getConfig: moonlightNode.getConfig.bind(moonlightNode),

     

       32
       32
        
           getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),

     

       33
       33
       +
           setConfigOption: moonlightNode.setConfigOption.bind(moonlightNode),

     

       34
       34
       +
       

     

       33
       35
        
           getNatives: moonlightNode.getNatives.bind(moonlightNode),

     

       34
       36
        
           getLogger(id) {

     

       35
       37
        
             return new Logger(id);