commit 024b884eb06b05cc3c611afdbef4fe42764d0cb0 · notnite.com/moonlight

+28 -3

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

···

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

     

       2
       2
       -
       import { ExtensionState, MoonbaseExtension, MoonbaseNatives, RepositoryManifest, RestartAdvice } from "../types";

     

       2
       2
       +
       import {

     

       3
       3
       +
         ExtensionState,

     

       4
       4
       +
         MoonbaseExtension,

     

       5
       5
       +
         MoonbaseNatives,

     

       6
       6
       +
         RepositoryManifest,

     

       7
       7
       +
         RestartAdvice,

     

       8
       8
       +
         UpdateState

     

       9
       9
       +
       } from "../types";

     

       3
       10
        
       import { Store } from "@moonlight-mod/wp/discord/packages/flux";

     

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

     

       5
       12
        
       import getNatives from "../native";

     
···

       25
       32
        
         submitting: boolean;

     

       26
       33
        
         installing: boolean;

     

       27
       34
        
       

     

       35
       35
       +
         #updateState = UpdateState.Ready;

     

       36
       36
       +
         get updateState() {

     

       37
       37
       +
           return this.#updateState;

     

       38
       38
       +
         }

     

       28
       39
        
         newVersion: string | null;

     

       29
       40
        
         shouldShowNotice: boolean;

     

       30
       41
        
       

     
···

       353
       364
        
         }

     

       354
       365
        
       

     

       355
       366
        
         async updateMoonlight() {

     

       356
       356
       -
           await natives.updateMoonlight();

     

       367
       367
       +
           this.#updateState = UpdateState.Working;

     

       368
       368
       +
           this.emitChange();

     

       369
       369
       +
       

     

       370
       370
       +
           await natives

     

       371
       371
       +
             .updateMoonlight()

     

       372
       372
       +
             .then(() => (this.#updateState = UpdateState.Installed))

     

       373
       373
       +
             .catch((e) => {

     

       374
       374
       +
               logger.error(e);

     

       375
       375
       +
               this.#updateState = UpdateState.Failed;

     

       376
       376
       +
             });

     

       377
       377
       +
       

     

       378
       378
       +
           this.emitChange();

     

       357
       379
        
         }

     

       358
       380
        
       

     

       359
       381
        
         getConfigOption<K extends keyof Config>(key: K): Config[K] {

     
···

       381
       403
        
         }

     

       382
       404
        
       

     

       383
       405
        
         #computeRestartAdvice() {

     

       406
       406
       +
           // If moonlight update needs a restart, always hide advice.

     

       407
       407
       +
           if (this.#updateState === UpdateState.Installed) return RestartAdvice.NotNeeded;

     

       408
       408
       +
       

     

       384
       409
        
           const i = this.initialConfig; // Initial config, from startup

     

       385
       410
        
           const n = this.config; // New config about to be saved

     

       386
       411
        
       

     
···

       486
       511
        
           this.modified = false;

     

       487
       512
        
           this.emitChange();

     

       488
       513
        
       

     

       489
       489
       -
           if (modifiedRepos) this.checkUpdates();

     

       514
       514
       +
           if (modifiedRepos.length !== 0) this.checkUpdates();

     

       490
       515
        
         }

     

       491
       516
        
       

     

       492
       517
        
         reset() {

+5 -12

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

···

       20
       20
        
       } from "@moonlight-mod/wp/discord/components/common/index";

     

       21
       21
        
       import MarkupClasses from "@moonlight-mod/wp/discord/modules/messages/web/Markup.css";

     

       22
       22
        
       

     

       23
       23
       -
       const logger = moonlight.getLogger("moonbase/ui/update");

     

       24
       24
       -
       

     

       25
       23
        
       const strings: Record<UpdateState, string> = {

     

       26
       24
        
         [UpdateState.Ready]: "A new version of moonlight is available.",

     

       27
       25
        
         [UpdateState.Working]: "Updating moonlight...",

     
···

       67
       65
        
       }

     

       68
       66
        
       

     

       69
       67
        
       export default function Update() {

     

       70
       70
       -
         const [state, setState] = React.useState(UpdateState.Ready);

     

       71
       71
       -
         const newVersion = useStateFromStores([MoonbaseSettingsStore], () => MoonbaseSettingsStore.newVersion);

     

       68
       68
       +
         const [newVersion, state] = useStateFromStores([MoonbaseSettingsStore], () => [

     

       69
       69
       +
           MoonbaseSettingsStore.newVersion,

     

       70
       70
       +
           MoonbaseSettingsStore.updateState

     

       71
       71
       +
         ]);

     

       72
       72
        
       

     

       73
       73
        
         if (newVersion == null) return null;

     

       74
       74
        
       

     
···

       113
       113
        
                 size={Button.Sizes.TINY}

     

       114
       114
        
                 disabled={state !== UpdateState.Ready}

     

       115
       115
        
                 onClick={() => {

     

       116
       116
       -
                   setState(UpdateState.Working);

     

       117
       117
       -
       

     

       118
       118
       -
                   MoonbaseSettingsStore.updateMoonlight()

     

       119
       119
       -
                     .then(() => setState(UpdateState.Installed))

     

       120
       120
       -
                     .catch((e) => {

     

       121
       121
       -
                       logger.error(e);

     

       122
       122
       -
                       setState(UpdateState.Failed);

     

       123
       123
       -
                     });

     

       116
       116
       +
                   MoonbaseSettingsStore.updateMoonlight();

     

       124
       117
        
                 }}

     

       125
       118
        
               >

     

       126
       119
        
                 Update