commit 4c998a508bb334cbd028dc80c774378b32284610 · notnite.com/moonlight

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

···

       40
        
       

     

       41
        
       export type MoonbaseExtension = {

     

       42
        
         id: string;

     

       0
        
       
     

       43
        
         manifest: ExtensionManifest | RepositoryManifest;

     

       44
        
         source: DetectedExtension["source"];

     

       45
        
         state: ExtensionState;

···

       40
        
       

     

       41
        
       export type MoonbaseExtension = {

     

       42
        
         id: string;

     

       43
       +
         uniqueId: number;

     

       44
        
         manifest: ExtensionManifest | RepositoryManifest;

     

       45
        
         source: DetectedExtension["source"];

     

       46
        
         state: ExtensionState;

+92 -80

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

···

       1
        
       import { Config, ExtensionLoadSource } from "@moonlight-mod/types";

     

       2
       -
       import {

     

       3
       -
         ExtensionState,

     

       4
       -
         MoonbaseExtension,

     

       5
       -
         MoonbaseNatives,

     

       6
       -
         RepositoryManifest

     

       7
       -
       } from "../types";

     

       8
        
       import Flux from "@moonlight-mod/wp/common_flux";

     

       9
        
       import Dispatcher from "@moonlight-mod/wp/common_fluxDispatcher";

     

       10
        
       

     
···

       14
        
       class MoonbaseSettingsStore extends Flux.Store<any> {

     

       15
        
         private origConfig: Config;

     

       16
        
         private config: Config;

     

       0
        
       
     

       17
        
       

     

       18
        
         modified: boolean;

     

       19
        
         submitting: boolean;

     

       20
        
         installing: boolean;

     

       21
        
       

     

       22
       -
         extensions: { [id: string]: MoonbaseExtension };

     

       23
       -
         updates: { [id: string]: { version: string; download: string } };

     

       24
        
       

     

       25
        
         constructor() {

     

       26
        
           super(Dispatcher);

     

       27
        
       

     

       28
        
           this.origConfig = moonlightNode.config;

     

       29
        
           this.config = this.clone(this.origConfig);

     

       0
        
       
     

       30
        
       

     

       31
        
           this.modified = false;

     

       32
        
           this.submitting = false;

     
···

       35
        
           this.extensions = {};

     

       36
        
           this.updates = {};

     

       37
        
           for (const ext of moonlightNode.extensions) {

     

       38
       -
             const existingExtension = this.extensions[ext.id];

     

       39
       -
             if (existingExtension != null) continue;

     

       40
       -
       

     

       41
       -
             this.extensions[ext.id] = {

     

       42
        
               ...ext,

     

       0
        
       
     

       43
        
               state: moonlight.enabledExtensions.has(ext.id)

     

       44
        
                 ? ExtensionState.Enabled

     

       45
        
                 : ExtensionState.Disabled

     
···

       50
        
             for (const [repo, exts] of Object.entries(ret)) {

     

       51
        
               try {

     

       52
        
                 for (const ext of exts) {

     

       53
       -
                   try {

     

       54
       -
                     const existingExtension = this.extensions[ext.id];

     

       55
       -
                     if (existingExtension !== undefined) {

     

       56
       -
                       if (this.hasUpdate(repo, ext, existingExtension)) {

     

       57
       -
                         this.updates[ext.id] = {

     

       58
       -
                           version: ext.version!,

     

       59
       -
                           download: ext.download

     

       60
       -
                         };

     

       61
       -
                       }

     

       62
        
       

     

       63
       -
                       this.extensions[ext.id].manifest = ext;

     

       64
       -
                       this.extensions[ext.id].source = {

     

       65
       -
                         type: ExtensionLoadSource.Normal,

     

       66
       -
                         url: repo

     

       0
        
       
     

       67
        
                       };

     

       68
       -
       

     

       69
       -
                       continue;

     

       70
        
                     }

     

       71
        
       

     

       72
       -
                     this.extensions[ext.id] = {

     

       73
       -
                       id: ext.id,

     

       74
       -
                       manifest: ext,

     

       75
       -
                       source: { type: ExtensionLoadSource.Normal, url: repo },

     

       76
       -
                       state: ExtensionState.NotDownloaded

     

       77
       -
                     };

     

       78
       -
                   } catch (e) {

     

       79
       -
                     logger.error(`Error processing extension ${ext.id}`, e);

     

       80
        
                   }

     

       0
        
       
     

       0
        
       
     

       81
        
                 }

     

       82
        
               } catch (e) {

     

       83
        
                 logger.error(`Error processing repository ${repo}`, e);

     
···

       88
        
           });

     

       89
        
         }

     

       90
        
       

     

       91
       -
         // this logic sucks so bad lol

     

       92
       -
         private hasUpdate(

     

       93
       -
           repo: string,

     

       94
       -
           repoExt: RepositoryManifest,

     

       95
       -
           existing: MoonbaseExtension

     

       96
       -
         ) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       97
        
           return (

     

       98
       -
             existing.source.type === ExtensionLoadSource.Normal &&

     

       99
       -
             existing.source.url != null &&

     

       100
       -
             existing.source.url === repo &&

     

       101
       -
             repoExt.version != null &&

     

       102
       -
             existing.manifest.version !== repoExt.version

     

       103
        
           );

     

       104
        
         }

     

       105
        
       

     
···

       118
        
           return this.modified;

     

       119
        
         }

     

       120
        
       

     

       121
       -
         getExtension(id: string) {

     

       122
       -
           return this.extensions[id];

     

       123
        
         }

     

       124
        
       

     

       125
       -
         getExtensionName(id: string) {

     

       126
       -
           return Object.prototype.hasOwnProperty.call(this.extensions, id)

     

       127
       -
             ? this.extensions[id].manifest.meta?.name ?? id

     

       128
       -
             : id;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       129
        
         }

     

       130
        
       

     

       131
       -
         getExtensionUpdate(id: string) {

     

       132
       -
           return Object.prototype.hasOwnProperty.call(this.updates, id)

     

       133
       -
             ? this.updates[id]

     

       134
       -
             : null;

     

       135
        
         }

     

       136
        
       

     

       137
       -
         getExtensionEnabled(id: string) {

     

       138
       -
           const val = this.config.extensions[id];

     

       0
        
       
     

       0
        
       
     

       139
        
           if (val == null) return false;

     

       140
        
           return typeof val === "boolean" ? val : val.enabled;

     

       141
        
         }

     

       142
        
       

     

       143
       -
         getExtensionConfig<T>(id: string, key: string): T | undefined {

     

       144
       -
           const defaultValue = this.extensions[id].manifest.settings?.[key]?.default;

     

       0
        
       
     

       145
        
           const clonedDefaultValue = this.clone(defaultValue);

     

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

     

       147
        
       

     

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

     

       149
        
           return cfg.config?.[key] ?? clonedDefaultValue;

     

       150
        
         }

     

       151
        
       

     

       152
       -
         getExtensionConfigName(id: string, key: string) {

     

       153
       -
           return this.extensions[id].manifest.settings?.[key]?.displayName ?? key;

     

       0
        
       
     

       154
        
         }

     

       155
        
       

     

       156
       -
         getExtensionConfigDescription(id: string, key: string) {

     

       157
       -
           return this.extensions[id].manifest.settings?.[key]?.description;

     

       0
        
       
     

       158
        
         }

     

       159
        
       

     

       160
       -
         setExtensionConfig(id: string, key: string, value: any) {

     

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

     

       0
        
       
     

       162
        
           const newConfig =

     

       163
        
             typeof oldConfig === "boolean"

     

       164
        
               ? {

     
···

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

     

       171
        
                 };

     

       172
        
       

     

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

     

       174
        
           this.modified = this.isModified();

     

       175
        
           this.emitChange();

     

       176
        
         }

     

       177
        
       

     

       178
       -
         setExtensionEnabled(id: string, enabled: boolean) {

     

       179
       -
           let val = this.config.extensions[id];

     

       0
        
       
     

       180
        
       

     

       181
        
           if (val == null) {

     

       182
       -
             this.config.extensions[id] = { enabled };

     

       183
        
             this.modified = this.isModified();

     

       184
        
             this.emitChange();

     

       185
        
             return;

     
···

       191
        
             val.enabled = enabled;

     

       192
        
           }

     

       193
        
       

     

       194
       -
           this.config.extensions[id] = val;

     

       195
        
           this.modified = this.isModified();

     

       196
        
           this.emitChange();

     

       197
        
         }

     

       198
        
       

     

       199
       -
         async installExtension(id: string) {

     

       200
       -
           const ext = this.getExtension(id);

     

       201
        
           if (!("download" in ext.manifest)) {

     

       202
        
             throw new Error("Extension has no download URL");

     

       203
        
           }

     

       204
        
       

     

       205
        
           this.installing = true;

     

       206
        
           try {

     

       207
       -
             const url = this.updates[id]?.download ?? ext.manifest.download;

     

       208
        
             await natives.installExtension(ext.manifest, url, ext.source.url!);

     

       209
        
             if (ext.state === ExtensionState.NotDownloaded) {

     

       210
       -
               this.extensions[id].state = ExtensionState.Disabled;

     

       211
        
             }

     

       212
        
       

     

       213
       -
             delete this.updates[id];

     

       214
        
           } catch (e) {

     

       215
        
             logger.error("Error installing extension:", e);

     

       216
        
           }

     
···

       219
        
           this.emitChange();

     

       220
        
         }

     

       221
        
       

     

       222
       -
         async deleteExtension(id: string) {

     

       223
       -
           const ext = this.getExtension(id);

     

       224
        
           if (ext == null) return;

     

       225
        
       

     

       226
        
           this.installing = true;

     

       227
        
           try {

     

       228
        
             await natives.deleteExtension(ext.id);

     

       229
       -
             this.extensions[id].state = ExtensionState.NotDownloaded;

     

       230
        
           } catch (e) {

     

       231
        
             logger.error("Error deleting extension:", e);

     

       232
        
           }

···

       1
        
       import { Config, ExtensionLoadSource } from "@moonlight-mod/types";

     

       2
       +
       import { ExtensionState, MoonbaseExtension, MoonbaseNatives } from "../types";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3
        
       import Flux from "@moonlight-mod/wp/common_flux";

     

       4
        
       import Dispatcher from "@moonlight-mod/wp/common_fluxDispatcher";

     

       5
        
       

     
···

       9
        
       class MoonbaseSettingsStore extends Flux.Store<any> {

     

       10
        
         private origConfig: Config;

     

       11
        
         private config: Config;

     

       12
       +
         private extensionIndex: number;

     

       13
        
       

     

       14
        
         modified: boolean;

     

       15
        
         submitting: boolean;

     

       16
        
         installing: boolean;

     

       17
        
       

     

       18
       +
         extensions: { [id: number]: MoonbaseExtension };

     

       19
       +
         updates: { [id: number]: { version: string; download: string } };

     

       20
        
       

     

       21
        
         constructor() {

     

       22
        
           super(Dispatcher);

     

       23
        
       

     

       24
        
           this.origConfig = moonlightNode.config;

     

       25
        
           this.config = this.clone(this.origConfig);

     

       26
       +
           this.extensionIndex = 0;

     

       27
        
       

     

       28
        
           this.modified = false;

     

       29
        
           this.submitting = false;

     
···

       32
        
           this.extensions = {};

     

       33
        
           this.updates = {};

     

       34
        
           for (const ext of moonlightNode.extensions) {

     

       35
       +
             const uniqueId = this.extensionIndex++;

     

       36
       +
             this.extensions[uniqueId] = {

     

       0
        
       
     

       0
        
       
     

       37
        
               ...ext,

     

       38
       +
               uniqueId,

     

       39
        
               state: moonlight.enabledExtensions.has(ext.id)

     

       40
        
                 ? ExtensionState.Enabled

     

       41
        
                 : ExtensionState.Disabled

     
···

       46
        
             for (const [repo, exts] of Object.entries(ret)) {

     

       47
        
               try {

     

       48
        
                 for (const ext of exts) {

     

       49
       +
                   const uniqueId = this.extensionIndex++;

     

       50
       +
                   const extensionData = {

     

       51
       +
                     id: ext.id,

     

       52
       +
                     uniqueId,

     

       53
       +
                     manifest: ext,

     

       54
       +
                     source: { type: ExtensionLoadSource.Normal, url: repo },

     

       55
       +
                     state: ExtensionState.NotDownloaded

     

       56
       +
                   };

     

       0
        
       
     

       57
        
       

     

       58
       +
                   if (this.alreadyExists(extensionData)) {

     

       59
       +
                     if (this.hasUpdate(extensionData)) {

     

       60
       +
                       this.updates[uniqueId] = {

     

       61
       +
                         version: ext.version!,

     

       62
       +
                         download: ext.download

     

       63
        
                       };

     

       0
        
       
     

       0
        
       
     

       64
        
                     }

     

       65
        
       

     

       66
       +
                     continue;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
                   }

     

       68
       +
       

     

       69
       +
                   this.extensions[uniqueId] = extensionData;

     

       70
        
                 }

     

       71
        
               } catch (e) {

     

       72
        
                 logger.error(`Error processing repository ${repo}`, e);

     
···

       77
        
           });

     

       78
        
         }

     

       79
        
       

     

       80
       +
         private alreadyExists(ext: MoonbaseExtension) {

     

       81
       +
           return Object.values(this.extensions).some(

     

       82
       +
             (e) => e.id === ext.id && e.source.url === ext.source.url

     

       83
       +
           );

     

       84
       +
         }

     

       85
       +
       

     

       86
       +
         private hasUpdate(ext: MoonbaseExtension) {

     

       87
       +
           const existing = Object.values(this.extensions).find(

     

       88
       +
             (e) => e.id === ext.id && e.source.url === ext.source.url

     

       89
       +
           );

     

       90
       +
           if (existing == null) return false;

     

       91
       +
       

     

       92
        
           return (

     

       93
       +
             existing.manifest.version !== ext.manifest.version &&

     

       94
       +
             existing.state !== ExtensionState.NotDownloaded

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       95
        
           );

     

       96
        
         }

     

       97
        
       

     
···

       110
        
           return this.modified;

     

       111
        
         }

     

       112
        
       

     

       113
       +
         getExtension(uniqueId: number) {

     

       114
       +
           return this.extensions[uniqueId];

     

       115
        
         }

     

       116
        
       

     

       117
       +
         getExtensionUniqueId(id: string) {

     

       118
       +
           return Object.values(this.extensions).find((ext) => ext.id === id)

     

       119
       +
             ?.uniqueId;

     

       120
       +
         }

     

       121
       +
       

     

       122
       +
         getExtensionConflicting(uniqueId: number) {

     

       123
       +
           const ext = this.getExtension(uniqueId);

     

       124
       +
           if (ext.state !== ExtensionState.NotDownloaded) return false;

     

       125
       +
           return Object.values(this.extensions).some(

     

       126
       +
             (e) =>

     

       127
       +
               e.id === ext.id &&

     

       128
       +
               e.uniqueId !== uniqueId &&

     

       129
       +
               e.state !== ExtensionState.NotDownloaded

     

       130
       +
           );

     

       131
       +
         }

     

       132
       +
       

     

       133
       +
         getExtensionName(uniqueId: number) {

     

       134
       +
           const ext = this.getExtension(uniqueId);

     

       135
       +
           return ext.manifest.meta?.name ?? ext.id;

     

       136
        
         }

     

       137
        
       

     

       138
       +
         getExtensionUpdate(uniqueId: number) {

     

       139
       +
           return this.updates[uniqueId]?.version;

     

       0
        
       
     

       0
        
       
     

       140
        
         }

     

       141
        
       

     

       142
       +
         getExtensionEnabled(uniqueId: number) {

     

       143
       +
           const ext = this.getExtension(uniqueId);

     

       144
       +
           if (ext.state === ExtensionState.NotDownloaded) return false;

     

       145
       +
           const val = this.config.extensions[ext.id];

     

       146
        
           if (val == null) return false;

     

       147
        
           return typeof val === "boolean" ? val : val.enabled;

     

       148
        
         }

     

       149
        
       

     

       150
       +
         getExtensionConfig<T>(uniqueId: number, key: string): T | undefined {

     

       151
       +
           const ext = this.getExtension(uniqueId);

     

       152
       +
           const defaultValue = ext.manifest.settings?.[key]?.default;

     

       153
        
           const clonedDefaultValue = this.clone(defaultValue);

     

       154
       +
           const cfg = this.config.extensions[ext.id];

     

       155
        
       

     

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

     

       157
        
           return cfg.config?.[key] ?? clonedDefaultValue;

     

       158
        
         }

     

       159
        
       

     

       160
       +
         getExtensionConfigName(uniqueId: number, key: string) {

     

       161
       +
           const ext = this.getExtension(uniqueId);

     

       162
       +
           return ext.manifest.settings?.[key]?.displayName ?? key;

     

       163
        
         }

     

       164
        
       

     

       165
       +
         getExtensionConfigDescription(uniqueId: number, key: string) {

     

       166
       +
           const ext = this.getExtension(uniqueId);

     

       167
       +
           return ext.manifest.settings?.[key]?.description;

     

       168
        
         }

     

       169
        
       

     

       170
       +
         setExtensionConfig(uniqueId: number, key: string, value: any) {

     

       171
       +
           const ext = this.getExtension(uniqueId);

     

       172
       +
           const oldConfig = this.config.extensions[ext.id];

     

       173
        
           const newConfig =

     

       174
        
             typeof oldConfig === "boolean"

     

       175
        
               ? {

     
···

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

     

       182
        
                 };

     

       183
        
       

     

       184
       +
           this.config.extensions[ext.id] = newConfig;

     

       185
        
           this.modified = this.isModified();

     

       186
        
           this.emitChange();

     

       187
        
         }

     

       188
        
       

     

       189
       +
         setExtensionEnabled(uniqueId: number, enabled: boolean) {

     

       190
       +
           const ext = this.getExtension(uniqueId);

     

       191
       +
           let val = this.config.extensions[ext.id];

     

       192
        
       

     

       193
        
           if (val == null) {

     

       194
       +
             this.config.extensions[ext.id] = { enabled };

     

       195
        
             this.modified = this.isModified();

     

       196
        
             this.emitChange();

     

       197
        
             return;

     
···

       203
        
             val.enabled = enabled;

     

       204
        
           }

     

       205
        
       

     

       206
       +
           this.config.extensions[ext.id] = val;

     

       207
        
           this.modified = this.isModified();

     

       208
        
           this.emitChange();

     

       209
        
         }

     

       210
        
       

     

       211
       +
         async installExtension(uniqueId: number) {

     

       212
       +
           const ext = this.getExtension(uniqueId);

     

       213
        
           if (!("download" in ext.manifest)) {

     

       214
        
             throw new Error("Extension has no download URL");

     

       215
        
           }

     

       216
        
       

     

       217
        
           this.installing = true;

     

       218
        
           try {

     

       219
       +
             const url = this.updates[uniqueId]?.download ?? ext.manifest.download;

     

       220
        
             await natives.installExtension(ext.manifest, url, ext.source.url!);

     

       221
        
             if (ext.state === ExtensionState.NotDownloaded) {

     

       222
       +
               this.extensions[uniqueId].state = ExtensionState.Disabled;

     

       223
        
             }

     

       224
        
       

     

       225
       +
             delete this.updates[uniqueId];

     

       226
        
           } catch (e) {

     

       227
        
             logger.error("Error installing extension:", e);

     

       228
        
           }

     
···

       231
        
           this.emitChange();

     

       232
        
         }

     

       233
        
       

     

       234
       +
         async deleteExtension(uniqueId: number) {

     

       235
       +
           const ext = this.getExtension(uniqueId);

     

       236
        
           if (ext == null) return;

     

       237
        
       

     

       238
        
           this.installing = true;

     

       239
        
           try {

     

       240
        
             await natives.deleteExtension(ext.id);

     

       241
       +
             this.extensions[uniqueId].state = ExtensionState.NotDownloaded;

     

       242
        
           } catch (e) {

     

       243
        
             logger.error("Error deleting extension:", e);

     

       244
        
           }

+11 -9

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/card.tsx

···

       36
        
       const PanelButton =

     

       37
        
         spacepack.findByCode("Masks.PANEL_BUTTON")[0].exports.default;

     

       38
        
       

     

       39
       -
       export default function ExtensionCard({ id }: { id: string }) {

     

       40
        
         const [tab, setTab] = React.useState(ExtensionPage.Info);

     

       41
        
         const [restartNeeded, setRestartNeeded] = React.useState(false);

     

       42
        
       

     

       43
       -
         const { ext, enabled, busy, update } = Flux.useStateFromStores(

     

       44
        
           [MoonbaseSettingsStore],

     

       45
        
           () => {

     

       46
        
             return {

     

       47
       -
               ext: MoonbaseSettingsStore.getExtension(id),

     

       48
       -
               enabled: MoonbaseSettingsStore.getExtensionEnabled(id),

     

       49
        
               busy: MoonbaseSettingsStore.busy,

     

       50
       -
               update: MoonbaseSettingsStore.getExtensionUpdate(id)

     

       0
        
       
     

       51
        
             };

     

       52
        
           }

     

       53
        
         );

     
···

       96
        
                   <Button

     

       97
        
                     color={Button.Colors.BRAND}

     

       98
        
                     submitting={busy}

     

       0
        
       
     

       99
        
                     onClick={() => {

     

       100
       -
                       MoonbaseSettingsStore.installExtension(id);

     

       101
        
                     }}

     

       102
        
                   >

     

       103
        
                     Install

     
···

       116
        
                         icon={TrashIcon}

     

       117
        
                         tooltipText="Delete"

     

       118
        
                         onClick={() => {

     

       119
       -
                           MoonbaseSettingsStore.deleteExtension(id);

     

       120
        
                         }}

     

       121
        
                       />

     

       122
        
                     )}

     
···

       126
        
                         icon={DownloadIcon}

     

       127
        
                         tooltipText="Update"

     

       128
        
                         onClick={() => {

     

       129
       -
                           MoonbaseSettingsStore.installExtension(id);

     

       130
        
                         }}

     

       131
        
                       />

     

       132
        
                     )}

     
···

       147
        
                       checked={enabled}

     

       148
        
                       onChange={() => {

     

       149
        
                         setRestartNeeded(true);

     

       150
       -
                         MoonbaseSettingsStore.setExtensionEnabled(id, !enabled);

     

       151
        
                       }}

     

       152
        
                     />

     

       153
        
                   </div>

···

       36
        
       const PanelButton =

     

       37
        
         spacepack.findByCode("Masks.PANEL_BUTTON")[0].exports.default;

     

       38
        
       

     

       39
       +
       export default function ExtensionCard({ uniqueId }: { uniqueId: number }) {

     

       40
        
         const [tab, setTab] = React.useState(ExtensionPage.Info);

     

       41
        
         const [restartNeeded, setRestartNeeded] = React.useState(false);

     

       42
        
       

     

       43
       +
         const { ext, enabled, busy, update, conflicting } = Flux.useStateFromStores(

     

       44
        
           [MoonbaseSettingsStore],

     

       45
        
           () => {

     

       46
        
             return {

     

       47
       +
               ext: MoonbaseSettingsStore.getExtension(uniqueId),

     

       48
       +
               enabled: MoonbaseSettingsStore.getExtensionEnabled(uniqueId),

     

       49
        
               busy: MoonbaseSettingsStore.busy,

     

       50
       +
               update: MoonbaseSettingsStore.getExtensionUpdate(uniqueId),

     

       51
       +
               conflicting: MoonbaseSettingsStore.getExtensionConflicting(uniqueId)

     

       52
        
             };

     

       53
        
           }

     

       54
        
         );

     
···

       97
        
                   <Button

     

       98
        
                     color={Button.Colors.BRAND}

     

       99
        
                     submitting={busy}

     

       100
       +
                     disabled={conflicting}

     

       101
        
                     onClick={() => {

     

       102
       +
                       MoonbaseSettingsStore.installExtension(uniqueId);

     

       103
        
                     }}

     

       104
        
                   >

     

       105
        
                     Install

     
···

       118
        
                         icon={TrashIcon}

     

       119
        
                         tooltipText="Delete"

     

       120
        
                         onClick={() => {

     

       121
       +
                           MoonbaseSettingsStore.deleteExtension(uniqueId);

     

       122
        
                         }}

     

       123
        
                       />

     

       124
        
                     )}

     
···

       128
        
                         icon={DownloadIcon}

     

       129
        
                         tooltipText="Update"

     

       130
        
                         onClick={() => {

     

       131
       +
                           MoonbaseSettingsStore.installExtension(uniqueId);

     

       132
        
                         }}

     

       133
        
                       />

     

       134
        
                     )}

     
···

       149
        
                       checked={enabled}

     

       150
        
                       onChange={() => {

     

       151
        
                         setRestartNeeded(true);

     

       152
       +
                         MoonbaseSettingsStore.setExtensionEnabled(uniqueId, !enabled);

     

       153
        
                       }}

     

       154
        
                     />

     

       155
        
                   </div>

+6 -5

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/index.tsx

···

       14
        
         .exports.default;

     

       15
        
       

     

       16
        
       export default function ExtensionsPage() {

     

       0
        
       
     

       17
        
         const { extensions, savedFilter } = Flux.useStateFromStoresObject(

     

       18
        
           [MoonbaseSettingsStore],

     

       19
        
           () => {

     

       20
        
             return {

     

       21
        
               extensions: MoonbaseSettingsStore.extensions,

     

       22
        
               savedFilter: MoonbaseSettingsStore.getExtensionConfig(

     

       23
       -
                 "moonbase",

     

       24
        
                 "filter"

     

       25
        
               )

     

       26
        
             };

     
···

       33
        
         if (moonlight.getConfigOption<boolean>("moonbase", "saveFilter")) {

     

       34
        
           filter = savedFilter ?? defaultFilter;

     

       35
        
           setFilter = (filter) =>

     

       36
       -
             MoonbaseSettingsStore.setExtensionConfig("moonbase", "filter", filter);

     

       37
        
         } else {

     

       38
        
           const state = React.useState(defaultFilter);

     

       39
        
           filter = state[0];

     
···

       63
        
               (!(filter & Filter.Developer) &&

     

       64
        
                 ext.source.type === ExtensionLoadSource.Developer) ||

     

       65
        
               (!(filter & Filter.Enabled) &&

     

       66
       -
                 MoonbaseSettingsStore.getExtensionEnabled(ext.id)) ||

     

       67
        
               (!(filter & Filter.Disabled) &&

     

       68
       -
                 !MoonbaseSettingsStore.getExtensionEnabled(ext.id)) ||

     

       69
        
               (!(filter & Filter.Installed) &&

     

       70
        
                 ext.state !== ExtensionState.NotDownloaded) ||

     

       71
        
               (!(filter & Filter.Repository) &&

     
···

       97
        
               />

     

       98
        
             </React.Suspense>

     

       99
        
             {filtered.map((ext) => (

     

       100
       -
               <ExtensionCard id={ext.id} key={ext.id} />

     

       101
        
             ))}

     

       102
        
           </>

     

       103
        
         );

···

       14
        
         .exports.default;

     

       15
        
       

     

       16
        
       export default function ExtensionsPage() {

     

       17
       +
         const moonbaseId = MoonbaseSettingsStore.getExtensionUniqueId("moonbase")!;

     

       18
        
         const { extensions, savedFilter } = Flux.useStateFromStoresObject(

     

       19
        
           [MoonbaseSettingsStore],

     

       20
        
           () => {

     

       21
        
             return {

     

       22
        
               extensions: MoonbaseSettingsStore.extensions,

     

       23
        
               savedFilter: MoonbaseSettingsStore.getExtensionConfig(

     

       24
       +
                 moonbaseId,

     

       25
        
                 "filter"

     

       26
        
               )

     

       27
        
             };

     
···

       34
        
         if (moonlight.getConfigOption<boolean>("moonbase", "saveFilter")) {

     

       35
        
           filter = savedFilter ?? defaultFilter;

     

       36
        
           setFilter = (filter) =>

     

       37
       +
             MoonbaseSettingsStore.setExtensionConfig(moonbaseId, "filter", filter);

     

       38
        
         } else {

     

       39
        
           const state = React.useState(defaultFilter);

     

       40
        
           filter = state[0];

     
···

       64
        
               (!(filter & Filter.Developer) &&

     

       65
        
                 ext.source.type === ExtensionLoadSource.Developer) ||

     

       66
        
               (!(filter & Filter.Enabled) &&

     

       67
       +
                 MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       68
        
               (!(filter & Filter.Disabled) &&

     

       69
       +
                 !MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       70
        
               (!(filter & Filter.Installed) &&

     

       71
        
                 ext.state !== ExtensionState.NotDownloaded) ||

     

       72
        
               (!(filter & Filter.Repository) &&

     
···

       98
        
               />

     

       99
        
             </React.Suspense>

     

       100
        
             {filtered.map((ext) => (

     

       101
       +
               <ExtensionCard uniqueId={ext.uniqueId} key={ext.id} />

     

       102
        
             ))}

     

       103
        
           </>

     

       104
        
         );

+5 -1

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/info.tsx

···

       180
        
                     [DependencyType.Incompatible]: "var(--red-400)"

     

       181
        
                   };

     

       182
        
                   const color = colors[dep.type];

     

       183
       -
                   const name = MoonbaseSettingsStore.getExtensionName(dep.id);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       184
        
                   return (

     

       185
        
                     <Badge color={color} key={dep.id}>

     

       186
        
                       {name}

···

       180
        
                     [DependencyType.Incompatible]: "var(--red-400)"

     

       181
        
                   };

     

       182
        
                   const color = colors[dep.type];

     

       183
       +
                   const id = MoonbaseSettingsStore.getExtensionUniqueId(dep.id);

     

       184
       +
                   const name =

     

       185
       +
                     (id !== null

     

       186
       +
                       ? MoonbaseSettingsStore.getExtensionName(id!)

     

       187
       +
                       : null) ?? dep.id;

     

       188
        
                   return (

     

       189
        
                     <Badge color={color} key={dep.id}>

     

       190
        
                       {name}

+24 -21

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/settings.tsx

···

       31
        
       

     

       32
        
       const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       33
        
       

     

       34
       -
       function useConfigEntry<T>(id: string, name: string) {

     

       35
        
         return Flux.useStateFromStores(

     

       36
        
           [MoonbaseSettingsStore],

     

       37
        
           () => {

     

       38
        
             return {

     

       39
       -
               value: MoonbaseSettingsStore.getExtensionConfig<T>(id, name),

     

       40
       -
               displayName: MoonbaseSettingsStore.getExtensionConfigName(id, name),

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       41
        
               description: MoonbaseSettingsStore.getExtensionConfigDescription(

     

       42
       -
                 id,

     

       43
        
                 name

     

       44
        
               )

     

       45
        
             };

     

       46
        
           },

     

       47
       -
           [id, name]

     

       48
        
         );

     

       49
        
       }

     

       50
        
       

     

       51
        
       function Boolean({ ext, name, setting, disabled }: SettingsProps) {

     

       52
        
         const { FormSwitch } = CommonComponents;

     

       53
        
         const { value, displayName, description } = useConfigEntry<boolean>(

     

       54
       -
           ext.id,

     

       55
        
           name

     

       56
        
         );

     

       57
        
       

     
···

       61
        
             hideBorder={true}

     

       62
        
             disabled={disabled}

     

       63
        
             onChange={(value: boolean) => {

     

       64
       -
               MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       65
        
             }}

     

       66
        
             note={description}

     

       67
        
             className={`${Margins.marginReset} ${Margins.marginTop20}`}

     
···

       74
        
       function Number({ ext, name, setting, disabled }: SettingsProps) {

     

       75
        
         const { FormItem, FormText, Slider } = CommonComponents;

     

       76
        
         const { value, displayName, description } = useConfigEntry<number>(

     

       77
       -
           ext.id,

     

       78
        
           name

     

       79
        
         );

     

       80
        
       

     
···

       92
        
               maxValue={castedSetting.max ?? 100}

     

       93
        
               onValueChange={(value: number) => {

     

       94
        
                 const rounded = Math.max(min, Math.min(max, Math.round(value)));

     

       95
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, rounded);

     

       96
        
               }}

     

       97
        
             />

     

       98
        
           </FormItem>

     
···

       102
        
       function String({ ext, name, setting, disabled }: SettingsProps) {

     

       103
        
         const { FormItem, FormText, TextInput } = CommonComponents;

     

       104
        
         const { value, displayName, description } = useConfigEntry<string>(

     

       105
       -
           ext.id,

     

       106
        
           name

     

       107
        
         );

     

       108
        
       

     
···

       115
        
               value={value ?? ""}

     

       116
        
               onChange={(value: string) => {

     

       117
        
                 if (disabled) return;

     

       118
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       119
        
               }}

     

       120
        
             />

     

       121
        
           </FormItem>

     
···

       125
        
       function MultilineString({ ext, name, setting, disabled }: SettingsProps) {

     

       126
        
         const { FormItem, FormText, TextArea } = CommonComponents;

     

       127
        
         const { value, displayName, description } = useConfigEntry<string>(

     

       128
       -
           ext.id,

     

       129
        
           name

     

       130
        
         );

     

       131
        
       

     
···

       140
        
               className={"moonbase-resizeable"}

     

       141
        
               onChange={(value: string) => {

     

       142
        
                 if (disabled) return;

     

       143
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       144
        
               }}

     

       145
        
             />

     

       146
        
           </FormItem>

     
···

       150
        
       function Select({ ext, name, setting, disabled }: SettingsProps) {

     

       151
        
         const { FormItem, FormText, SingleSelect } = CommonComponents;

     

       152
        
         const { value, displayName, description } = useConfigEntry<string>(

     

       153
       -
           ext.id,

     

       154
        
           name

     

       155
        
         );

     

       156
        
       

     
···

       171
        
               )}

     

       172
        
               onChange={(value: string) => {

     

       173
        
                 if (disabled) return;

     

       174
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       175
        
               }}

     

       176
        
             />

     

       177
        
           </FormItem>

     
···

       182
        
         const { FormItem, FormText, Select, useVariableSelect, multiSelect } =

     

       183
        
           CommonComponents;

     

       184
        
         const { value, displayName, description } = useConfigEntry<string | string[]>(

     

       185
       -
           ext.id,

     

       186
        
           name

     

       187
        
         );

     

       188
        
       

     
···

       207
        
                 onChange: (value: string) => {

     

       208
        
                   if (disabled) return;

     

       209
        
                   MoonbaseSettingsStore.setExtensionConfig(

     

       210
       -
                     ext.id,

     

       211
        
                     name,

     

       212
        
                     Array.from(value)

     

       213
        
                   );

     
···

       249
        
       function List({ ext, name, setting, disabled }: SettingsProps) {

     

       250
        
         const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       251
        
         const { value, displayName, description } = useConfigEntry<string[]>(

     

       252
       -
           ext.id,

     

       253
        
           name

     

       254
        
         );

     

       255
        
       

     

       256
        
         const entries = value ?? [];

     

       257
        
         const updateConfig = () =>

     

       258
       -
           MoonbaseSettingsStore.setExtensionConfig(ext.id, name, entries);

     

       259
        
       

     

       260
        
         return (

     

       261
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     
···

       316
        
         const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       317
        
         const { value, displayName, description } = useConfigEntry<

     

       318
        
           Record<string, string>

     

       319
       -
         >(ext.id, name);

     

       320
        
       

     

       321
        
         const entries = Object.entries(value ?? {});

     

       322
        
         const updateConfig = () =>

     

       323
        
           MoonbaseSettingsStore.setExtensionConfig(

     

       324
       -
             ext.id,

     

       325
        
             name,

     

       326
        
             Object.fromEntries(entries)

     

       327
        
           );

···

       31
        
       

     

       32
        
       const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       33
        
       

     

       34
       +
       function useConfigEntry<T>(uniqueId: number, name: string) {

     

       35
        
         return Flux.useStateFromStores(

     

       36
        
           [MoonbaseSettingsStore],

     

       37
        
           () => {

     

       38
        
             return {

     

       39
       +
               value: MoonbaseSettingsStore.getExtensionConfig<T>(uniqueId, name),

     

       40
       +
               displayName: MoonbaseSettingsStore.getExtensionConfigName(

     

       41
       +
                 uniqueId,

     

       42
       +
                 name

     

       43
       +
               ),

     

       44
        
               description: MoonbaseSettingsStore.getExtensionConfigDescription(

     

       45
       +
                 uniqueId,

     

       46
        
                 name

     

       47
        
               )

     

       48
        
             };

     

       49
        
           },

     

       50
       +
           [uniqueId, name]

     

       51
        
         );

     

       52
        
       }

     

       53
        
       

     

       54
        
       function Boolean({ ext, name, setting, disabled }: SettingsProps) {

     

       55
        
         const { FormSwitch } = CommonComponents;

     

       56
        
         const { value, displayName, description } = useConfigEntry<boolean>(

     

       57
       +
           ext.uniqueId,

     

       58
        
           name

     

       59
        
         );

     

       60
        
       

     
···

       64
        
             hideBorder={true}

     

       65
        
             disabled={disabled}

     

       66
        
             onChange={(value: boolean) => {

     

       67
       +
               MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       68
        
             }}

     

       69
        
             note={description}

     

       70
        
             className={`${Margins.marginReset} ${Margins.marginTop20}`}

     
···

       77
        
       function Number({ ext, name, setting, disabled }: SettingsProps) {

     

       78
        
         const { FormItem, FormText, Slider } = CommonComponents;

     

       79
        
         const { value, displayName, description } = useConfigEntry<number>(

     

       80
       +
           ext.uniqueId,

     

       81
        
           name

     

       82
        
         );

     

       83
        
       

     
···

       95
        
               maxValue={castedSetting.max ?? 100}

     

       96
        
               onValueChange={(value: number) => {

     

       97
        
                 const rounded = Math.max(min, Math.min(max, Math.round(value)));

     

       98
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, rounded);

     

       99
        
               }}

     

       100
        
             />

     

       101
        
           </FormItem>

     
···

       105
        
       function String({ ext, name, setting, disabled }: SettingsProps) {

     

       106
        
         const { FormItem, FormText, TextInput } = CommonComponents;

     

       107
        
         const { value, displayName, description } = useConfigEntry<string>(

     

       108
       +
           ext.uniqueId,

     

       109
        
           name

     

       110
        
         );

     

       111
        
       

     
···

       118
        
               value={value ?? ""}

     

       119
        
               onChange={(value: string) => {

     

       120
        
                 if (disabled) return;

     

       121
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       122
        
               }}

     

       123
        
             />

     

       124
        
           </FormItem>

     
···

       128
        
       function MultilineString({ ext, name, setting, disabled }: SettingsProps) {

     

       129
        
         const { FormItem, FormText, TextArea } = CommonComponents;

     

       130
        
         const { value, displayName, description } = useConfigEntry<string>(

     

       131
       +
           ext.uniqueId,

     

       132
        
           name

     

       133
        
         );

     

       134
        
       

     
···

       143
        
               className={"moonbase-resizeable"}

     

       144
        
               onChange={(value: string) => {

     

       145
        
                 if (disabled) return;

     

       146
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       147
        
               }}

     

       148
        
             />

     

       149
        
           </FormItem>

     
···

       153
        
       function Select({ ext, name, setting, disabled }: SettingsProps) {

     

       154
        
         const { FormItem, FormText, SingleSelect } = CommonComponents;

     

       155
        
         const { value, displayName, description } = useConfigEntry<string>(

     

       156
       +
           ext.uniqueId,

     

       157
        
           name

     

       158
        
         );

     

       159
        
       

     
···

       174
        
               )}

     

       175
        
               onChange={(value: string) => {

     

       176
        
                 if (disabled) return;

     

       177
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       178
        
               }}

     

       179
        
             />

     

       180
        
           </FormItem>

     
···

       185
        
         const { FormItem, FormText, Select, useVariableSelect, multiSelect } =

     

       186
        
           CommonComponents;

     

       187
        
         const { value, displayName, description } = useConfigEntry<string | string[]>(

     

       188
       +
           ext.uniqueId,

     

       189
        
           name

     

       190
        
         );

     

       191
        
       

     
···

       210
        
                 onChange: (value: string) => {

     

       211
        
                   if (disabled) return;

     

       212
        
                   MoonbaseSettingsStore.setExtensionConfig(

     

       213
       +
                     ext.uniqueId,

     

       214
        
                     name,

     

       215
        
                     Array.from(value)

     

       216
        
                   );

     
···

       252
        
       function List({ ext, name, setting, disabled }: SettingsProps) {

     

       253
        
         const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       254
        
         const { value, displayName, description } = useConfigEntry<string[]>(

     

       255
       +
           ext.uniqueId,

     

       256
        
           name

     

       257
        
         );

     

       258
        
       

     

       259
        
         const entries = value ?? [];

     

       260
        
         const updateConfig = () =>

     

       261
       +
           MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, entries);

     

       262
        
       

     

       263
        
         return (

     

       264
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     
···

       319
        
         const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       320
        
         const { value, displayName, description } = useConfigEntry<

     

       321
        
           Record<string, string>

     

       322
       +
         >(ext.uniqueId, name);

     

       323
        
       

     

       324
        
         const entries = Object.entries(value ?? {});

     

       325
        
         const updateConfig = () =>

     

       326
        
           MoonbaseSettingsStore.setExtensionConfig(

     

       327
       +
             ext.uniqueId,

     

       328
        
             name,

     

       329
        
             Object.fromEntries(entries)

     

       330
        
           );