commit b2b316b4009c442886f2978462a8f0ce2a956925 · 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() {

+2 -2

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

···

       58
       58
        
         );

     

       59
       59
        
       }

     

       60
       60
        
       

     

       61
       61
       -
       export default function ExtensionCard({ uniqueId }: { uniqueId: number }) {

     

       61
       61
       +
       export default function ExtensionCard({ uniqueId, selectTag }: { uniqueId: number; selectTag: (tag: string) => void }) {

     

       62
       62
        
         const { ext, enabled, busy, update, conflicting } = useStateFromStores([MoonbaseSettingsStore], () => {

     

       63
       63
        
           return {

     

       64
       64
        
             ext: MoonbaseSettingsStore.getExtension(uniqueId),

     
···

       303
       303
        
                   rowGap: tab === ExtensionPage.Info ? "16px" : undefined

     

       304
       304
        
                 }}

     

       305
       305
        
               >

     

       306
       306
       -
                 {tab === ExtensionPage.Info && <ExtensionInfo ext={ext} />}

     

       306
       306
       +
                 {tab === ExtensionPage.Info && <ExtensionInfo ext={ext} selectTag={selectTag} />}

     

       307
       307
        
                 {tab === ExtensionPage.Description && (

     

       308
       308
        
                   <Text variant="text-md/normal" className={MarkupClasses.markup} style={{ width: "100%" }}>

     

       309
       309
        
                     {MarkupUtils.parse(description ?? "*No description*", true, {

+14 -2

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

···

       20
       20
        
       

     

       21
       21
        
       const SearchBar = spacepack.require("discord/uikit/search/SearchBar").default;

     

       22
       22
        
       

     

       23
       23
       +
       const validTags: string[] = Object.values(ExtensionTag);

     

       24
       24
       +
       

     

       23
       25
        
       export default function ExtensionsPage() {

     

       24
       26
        
         const { extensions, savedFilter } = useStateFromStoresObject([MoonbaseSettingsStore], () => {

     

       25
       27
        
           return {

     
···

       41
       43
        
           filter = filterState[0];

     

       42
       44
        
           setFilter = filterState[1];

     

       43
       45
        
         }

     

       46
       46
       +
       

     

       44
       47
        
         const [selectedTags, setSelectedTags] = React.useState(new Set<string>());

     

       48
       48
       +
         const selectTag = React.useCallback(

     

       49
       49
       +
           (tag: string) => {

     

       50
       50
       +
             const newState = new Set(selectedTags);

     

       51
       51
       +
             if (validTags.includes(tag)) newState.add(tag);

     

       52
       52
       +
             setSelectedTags(newState);

     

       53
       53
       +
           },

     

       54
       54
       +
           [selectedTags]

     

       55
       55
       +
         );

     

       56
       56
       +
       

     

       45
       57
        
         const sorted = Object.values(extensions).sort((a, b) => {

     

       46
       58
        
           const aName = a.manifest.meta?.name ?? a.id;

     

       47
       59
        
           const bName = b.manifest.meta?.name ?? b.id;

     
···

       132
       144
        
             )}

     

       133
       145
        
       

     

       134
       146
        
             {filteredWithUpdates.map((ext) => (

     

       135
       135
       -
               <ExtensionCard uniqueId={ext.uniqueId} key={ext.uniqueId} />

     

       147
       147
       +
               <ExtensionCard uniqueId={ext.uniqueId} key={ext.uniqueId} selectTag={selectTag} />

     

       136
       148
        
             ))}

     

       137
       149
        
             {filteredWithUpdates.length > 0 && filteredWithoutUpdates.length > 0 && (

     

       138
       150
        
               <FormDivider className="moonbase-update-divider" />

     

       139
       151
        
             )}

     

       140
       152
        
             {filteredWithoutUpdates.map((ext) => (

     

       141
       141
       -
               <ExtensionCard uniqueId={ext.uniqueId} key={ext.uniqueId} />

     

       153
       153
       +
               <ExtensionCard uniqueId={ext.uniqueId} key={ext.uniqueId} selectTag={selectTag} />

     

       142
       154
        
             ))}

     

       143
       155
        
           </>

     

       144
       156
        
         );

+13 -3

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

···

       54
       54
        
       function Badge({

     

       55
       55
        
         color,

     

       56
       56
        
         children,

     

       57
       57
       -
         style = {}

     

       57
       57
       +
         style = {},

     

       58
       58
       +
         onClick

     

       58
       59
        
       }: {

     

       59
       60
        
         color: string;

     

       60
       61
        
         children: React.ReactNode;

     

       61
       62
        
         style?: React.CSSProperties;

     

       63
       63
       +
         onClick?: () => void;

     

       62
       64
        
       }) {

     

       65
       65
       +
         if (onClick) style.cursor ??= "pointer";

     

       63
       66
        
         return (

     

       64
       67
        
           <span

     

       65
       68
        
             className="moonlight-card-badge"

     
···

       69
       72
        
                 ...style

     

       70
       73
        
               } as React.CSSProperties

     

       71
       74
        
             }

     

       75
       75
       +
             onClick={onClick}

     

       72
       76
        
           >

     

       73
       77
        
             {children}

     

       74
       78
        
           </span>

     

       75
       79
        
         );

     

       76
       80
        
       }

     

       77
       81
        
       

     

       78
       78
       -
       export default function ExtensionInfo({ ext }: { ext: MoonbaseExtension }) {

     

       82
       82
       +
       export default function ExtensionInfo({

     

       83
       83
       +
         ext,

     

       84
       84
       +
         selectTag

     

       85
       85
       +
       }: {

     

       86
       86
       +
         ext: MoonbaseExtension;

     

       87
       87
       +
         selectTag: (tag: string) => void;

     

       88
       88
       +
       }) {

     

       79
       89
        
         const authors = ext.manifest?.meta?.authors;

     

       80
       90
        
         const tags = ext.manifest?.meta?.tags;

     

       81
       91
        
         const version = ext.manifest?.version;

     
···

       148
       158
        
                   }

     

       149
       159
        
       

     

       150
       160
        
                   return (

     

       151
       151
       -
                     <Badge key={i} color={color} style={style}>

     

       161
       161
       +
                     <Badge key={i} color={color} style={style} onClick={() => selectTag(tag)}>

     

       152
       162
        
                       {name}

     

       153
       163
        
                     </Badge>

     

       154
       164
        
                   );

+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