commit 045cb1af6cd4109193671b9280326e9767fc5b84 · notnite.com/moonlight

+8 -40

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

···

       1
       1
       -
       import { ExtensionWebpackModule, Patch } from "@moonlight-mod/types";

     

       1
       1
       +
       import { ExtensionWebpackModule } from "@moonlight-mod/types";

     

       2
       2
        
       

     

       3
       3
        
       export const webpackModules: Record<string, ExtensionWebpackModule> = {

     

       4
       4
        
         stores: {

     
···

       33
       33
        
       

     

       34
       34
        
         updates: {

     

       35
       35
        
           dependencies: [

     

       36
       36
       -
             { id: "discord/Dispatcher" },

     

       37
       37
       -
             { ext: "moonbase", id: "stores" }

     

       38
       38
       -
           ],

     

       39
       39
       -
           entrypoint: true

     

       40
       40
       -
         },

     

       41
       41
       -
       

     

       42
       42
       -
         updatesNotice: {

     

       43
       43
       -
           dependencies: [

     

       44
       36
        
             { id: "react" },

     

       45
       45
       -
             { id: "discord/Dispatcher" },

     

       46
       46
       -
             { id: "discord/components/common/index" },

     

       47
       47
       -
             { id: "discord/packages/flux" },

     

       48
       48
       -
             { ext: "spacepack", id: "spacepack" },

     

       49
       49
       -
             { ext: "moonbase", id: "stores" }

     

       50
       50
       -
           ]

     

       51
       51
       -
         }

     

       52
       52
       -
       };

     

       53
       53
       -
       

     

       54
       54
       -
       export const patches: Patch[] = [

     

       55
       55
       -
         {

     

       56
       56
       -
           find: ".GUILD_RAID_NOTIFICATION:",

     

       57
       57
       -
           replace: {

     

       58
       58
       -
             match:

     

       59
       59
       -
               /(?<=return(\(0,.\.jsx\))\(.+?\);)case .{1,2}\..{1,3}\.GUILD_RAID_NOTIFICATION:/,

     

       60
       60
       -
             replacement: (orig, createElement) =>

     

       61
       61
       -
               `case "__moonlight_updates":return${createElement}(require("moonbase_updatesNotice").default,{});${orig}`

     

       62
       62
       -
           }

     

       63
       63
       -
         },

     

       64
       64
       -
         {

     

       65
       65
       -
           find: '"NoticeStore"',

     

       66
       66
       -
           replace: [

     

       67
       67
       -
             {

     

       68
       68
       -
               match: /\[.{1,2}\..{1,3}\.CONNECT_SPOTIFY\]:{/,

     

       69
       69
       -
               replacement: (orig: string) =>

     

       70
       70
       -
                 `__moonlight_updates:{predicate:()=>require("moonbase_stores").MoonbaseSettingsStore.shouldShowUpdateNotice()},${orig}`

     

       71
       71
       -
             },

     

       37
       37
       +
             { ext: "moonbase", id: "stores" },

     

       38
       38
       +
             { ext: "notices", id: "notices" },

     

       72
       39
        
             {

     

       73
       73
       -
               match: /=\[(.{1,2}\..{1,3}\.QUARANTINED,)/g,

     

       74
       74
       -
               replacement: (_, orig) => `=["__moonlight_updates",${orig}`

     

       40
       40
       +
               ext: "spacepack",

     

       41
       41
       +
               id: "spacepack"

     

       75
       42
        
             }

     

       76
       76
       -
           ]

     

       43
       43
       +
           ],

     

       44
       44
       +
           entrypoint: true

     

       77
       45
        
         }

     

       78
       78
       -
       ];

     

       46
       46
       +
       };

     

       79
       47
        
       

     

       80
       48
        
       export const styles = [

     

       81
       49
        
         ".moonbase-settings > :first-child { margin-top: 0px; }",

+1 -1

packages/core-extensions/src/moonbase/manifest.json

···

       6
       6
        
           "tagline": "The official settings UI for moonlight",

     

       7
       7
        
           "authors": ["Cynosphere", "NotNite"]

     

       8
       8
        
         },

     

       9
       9
       -
         "dependencies": ["spacepack", "settings", "common"],

     

       9
       9
       +
         "dependencies": ["spacepack", "settings", "common", "notices"],

     

       10
       10
        
         "settings": {

     

       11
       11
        
           "sections": {

     

       12
       12
        
             "displayName": "Split into sections",

+23 -18

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

···

       8
       8
        
       const logger = moonlightNode.getLogger("moonbase");

     

       9
       9
        
       

     

       10
       10
        
       async function checkForMoonlightUpdate() {

     

       11
       11
       -
         if (moonlightNode.branch === "stable") {

     

       12
       12
       -
           const req = await fetch(

     

       13
       13
       -
             `https://api.github.com/repos/${githubRepo}/releases/latest`,

     

       14
       14
       -
             {

     

       11
       11
       +
         try {

     

       12
       12
       +
           if (moonlightNode.branch === "stable") {

     

       13
       13
       +
             const req = await fetch(

     

       14
       14
       +
               `https://api.github.com/repos/${githubRepo}/releases/latest`,

     

       15
       15
       +
               {

     

       16
       16
       +
                 headers: {

     

       17
       17
       +
                   "User-Agent": userAgent

     

       18
       18
       +
                 }

     

       19
       19
       +
               }

     

       20
       20
       +
             );

     

       21
       21
       +
             const json: { name: string } = await req.json();

     

       22
       22
       +
             return json.name !== moonlightNode.version ? json.name : null;

     

       23
       23
       +
           } else if (moonlightNode.branch === "nightly") {

     

       24
       24
       +
             const req = await fetch(nightlyRefUrl, {

     

       15
       25
        
               headers: {

     

       16
       26
        
                 "User-Agent": userAgent

     

       17
       27
        
               }

     

       18
       18
       -
             }

     

       19
       19
       -
           );

     

       20
       20
       -
           const json: { name: string } = await req.json();

     

       21
       21
       -
           return json.name !== moonlightNode.version ? json.name : null;

     

       22
       22
       -
         } else if (moonlightNode.branch === "nightly") {

     

       23
       23
       -
           const req = await fetch(nightlyRefUrl, {

     

       24
       24
       -
             headers: {

     

       25
       25
       -
               "User-Agent": userAgent

     

       26
       26
       -
             }

     

       27
       27
       -
           });

     

       28
       28
       -
           const ref = (await req.text()).split("\n")[0];

     

       29
       29
       -
           return ref !== moonlightNode.version ? ref : null;

     

       30
       30
       -
         }

     

       28
       28
       +
             });

     

       29
       29
       +
             const ref = (await req.text()).split("\n")[0];

     

       30
       30
       +
             return ref !== moonlightNode.version ? ref : null;

     

       31
       31
       +
           }

     

       31
       32
        
       

     

       32
       32
       -
         return null;

     

       33
       33
       +
           return null;

     

       34
       34
       +
         } catch (e) {

     

       35
       35
       +
           logger.error("Error checking for moonlight update", e);

     

       36
       36
       +
           return null;

     

       37
       37
       +
         }

     

       33
       38
        
       }

     

       34
       39
        
       

     

       35
       40
        
       async function fetchRepositories(repos: string[]) {

+65 -69

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

···

       18
       18
        
         const browserFS = window._moonlightBrowserFS!;

     

       19
       19
        
         natives = {

     

       20
       20
        
           checkForMoonlightUpdate: async () => {

     

       21
       21
       -
             // TODO

     

       22
       22
       -
             if (moonlight.branch === "stable") {

     

       23
       23
       -
               const req = await fetch(

     

       24
       24
       -
                 `https://api.github.com/repos/${githubRepo}/releases/latest`,

     

       25
       25
       -
                 {

     

       21
       21
       +
             try {

     

       22
       22
       +
               if (moonlight.branch === "stable") {

     

       23
       23
       +
                 const req = await fetch(

     

       24
       24
       +
                   `https://api.github.com/repos/${githubRepo}/releases/latest`,

     

       25
       25
       +
                   {

     

       26
       26
       +
                     headers: {

     

       27
       27
       +
                       "User-Agent": userAgent

     

       28
       28
       +
                     }

     

       29
       29
       +
                   }

     

       30
       30
       +
                 );

     

       31
       31
       +
                 const json: { name: string } = await req.json();

     

       32
       32
       +
                 return json.name !== moonlight.version ? json.name : null;

     

       33
       33
       +
               } else if (moonlight.branch === "nightly") {

     

       34
       34
       +
                 const req = await fetch(nightlyRefUrl, {

     

       26
       35
        
                   headers: {

     

       27
       36
        
                     "User-Agent": userAgent

     

       28
       37
        
                   }

     

       29
       29
       -
                 }

     

       30
       30
       -
               );

     

       31
       31
       -
               const json: { name: string } = await req.json();

     

       32
       32
       -
               return json.name !== moonlight.version ? json.name : null;

     

       33
       33
       -
             } else if (moonlight.branch === "nightly") {

     

       34
       34
       -
               const req = await fetch(nightlyRefUrl, {

     

       35
       35
       -
                 headers: {

     

       36
       36
       -
                   "User-Agent": userAgent

     

       37
       37
       -
                 }

     

       38
       38
       -
               });

     

       39
       39
       -
               const ref = (await req.text()).split("\n")[0];

     

       40
       40
       -
               return ref !== moonlight.version ? ref : null;

     

       41
       41
       -
             }

     

       38
       38
       +
                 });

     

       39
       39
       +
                 const ref = (await req.text()).split("\n")[0];

     

       40
       40
       +
                 return ref !== moonlight.version ? ref : null;

     

       41
       41
       +
               }

     

       42
       42
        
       

     

       43
       43
       -
             return null;

     

       43
       43
       +
               return null;

     

       44
       44
       +
             } catch (e) {

     

       45
       45
       +
               logger.error("Error checking for moonlight update", e);

     

       46
       46
       +
               return null;

     

       47
       47
       +
             }

     

       44
       48
        
           },

     

       45
       49
        
       

     

       46
       50
        
           fetchRepositories: async (repos) => {

     
···

       105
       109
        
         installing: boolean;

     

       106
       110
        
       

     

       107
       111
        
         newVersion: string | null;

     

       108
       108
       -
         private updateNotice: boolean;

     

       112
       112
       +
         shouldShowNotice: boolean;

     

       109
       113
        
       

     

       110
       114
        
         extensions: { [id: number]: MoonbaseExtension };

     

       111
       115
        
         updates: { [id: number]: { version: string; download: string } };

     
···

       122
       126
        
           this.installing = false;

     

       123
       127
        
       

     

       124
       128
        
           this.newVersion = null;

     

       125
       125
       -
           this.updateNotice = false;

     

       129
       129
       +
           this.shouldShowNotice = false;

     

       126
       130
        
       

     

       127
       131
        
           this.extensions = {};

     

       128
       132
        
           this.updates = {};

     
···

       137
       141
        
             };

     

       138
       142
        
           }

     

       139
       143
        
       

     

       140
       140
       -
           natives!.fetchRepositories(this.config.repositories).then((ret) => {

     

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

     

       142
       142
       -
               try {

     

       143
       143
       -
                 for (const ext of exts) {

     

       144
       144
       -
                   const level = ext.apiLevel ?? 1;

     

       145
       145
       -
                   if (level !== window.moonlight.apiLevel) continue;

     

       144
       144
       +
           natives!

     

       145
       145
       +
             .fetchRepositories(this.config.repositories)

     

       146
       146
       +
             .then((ret) => {

     

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

     

       148
       148
       +
                 try {

     

       149
       149
       +
                   for (const ext of exts) {

     

       150
       150
       +
                     const level = ext.apiLevel ?? 1;

     

       151
       151
       +
                     if (level !== window.moonlight.apiLevel) continue;

     

       146
       152
        
       

     

       147
       147
       -
                   const uniqueId = this.extensionIndex++;

     

       148
       148
       -
                   const extensionData = {

     

       149
       149
       -
                     id: ext.id,

     

       150
       150
       -
                     uniqueId,

     

       151
       151
       -
                     manifest: ext,

     

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

     

       153
       153
       -
                     state: ExtensionState.NotDownloaded

     

       154
       154
       -
                   };

     

       153
       153
       +
                     const uniqueId = this.extensionIndex++;

     

       154
       154
       +
                     const extensionData = {

     

       155
       155
       +
                       id: ext.id,

     

       156
       156
       +
                       uniqueId,

     

       157
       157
       +
                       manifest: ext,

     

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

     

       159
       159
       +
                       state: ExtensionState.NotDownloaded

     

       160
       160
       +
                     };

     

       155
       161
        
       

     

       156
       156
       -
                   if (this.alreadyExists(extensionData)) {

     

       157
       157
       -
                     if (this.hasUpdate(extensionData)) {

     

       158
       158
       -
                       this.updates[uniqueId] = {

     

       159
       159
       -
                         version: ext.version!,

     

       160
       160
       -
                         download: ext.download

     

       161
       161
       -
                       };

     

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

     

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

     

       164
       164
       +
                         this.updates[uniqueId] = {

     

       165
       165
       +
                           version: ext.version!,

     

       166
       166
       +
                           download: ext.download

     

       167
       167
       +
                         };

     

       168
       168
       +
                       }

     

       169
       169
       +
       

     

       170
       170
       +
                       continue;

     

       162
       171
        
                     }

     

       163
       172
        
       

     

       164
       164
       -
                     continue;

     

       173
       173
       +
                     this.extensions[uniqueId] = extensionData;

     

       165
       174
        
                   }

     

       166
       166
       -
       

     

       167
       167
       -
                   this.extensions[uniqueId] = extensionData;

     

       175
       175
       +
                 } catch (e) {

     

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

     

       168
       177
        
                 }

     

       169
       169
       -
               } catch (e) {

     

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

     

       171
       178
        
               }

     

       172
       172
       -
             }

     

       173
       179
        
       

     

       174
       174
       -
             this.emitChange();

     

       175
       175
       -
           });

     

       176
       176
       -
       

     

       177
       177
       -
           natives!.checkForMoonlightUpdate().then((version) => {

     

       178
       178
       -
             this.newVersion = version;

     

       179
       179
       -
       

     

       180
       180
       -
             this.emitChange();

     

       181
       181
       -
           });

     

       180
       180
       +
               this.emitChange();

     

       181
       181
       +
             })

     

       182
       182
       +
             .then(natives!.checkForMoonlightUpdate)

     

       183
       183
       +
             .then((version) => {

     

       184
       184
       +
               this.newVersion = version;

     

       185
       185
       +
               this.emitChange();

     

       186
       186
       +
             })

     

       187
       187
       +
             .then(() => {

     

       188
       188
       +
               this.shouldShowNotice =

     

       189
       189
       +
                 this.newVersion != null || Object.keys(this.updates).length > 0;

     

       190
       190
       +
               this.emitChange();

     

       191
       191
       +
             });

     

       182
       192
        
         }

     

       183
       193
        
       

     

       184
       194
        
         private alreadyExists(ext: MoonbaseExtension) {

     
···

       381
       391
        
           this.modified = false;

     

       382
       392
        
           this.config = this.clone(this.origConfig);

     

       383
       393
        
           this.emitChange();

     

       384
       384
       -
         }

     

       385
       385
       -
       

     

       386
       386
       -
         showUpdateNotice() {

     

       387
       387
       -
           this.updateNotice = true;

     

       388
       388
       -
           //this.emitChange();

     

       389
       389
       -
         }

     

       390
       390
       -
       

     

       391
       391
       -
         dismissUpdateNotice() {

     

       392
       392
       -
           this.updateNotice = false;

     

       393
       393
       -
           //this.emitChange();

     

       394
       394
       -
         }

     

       395
       395
       -
       

     

       396
       396
       -
         shouldShowUpdateNotice() {

     

       397
       397
       -
           return this.updateNotice;

     

       398
       394
        
         }

     

       399
       395
        
       

     

       400
       396
        
         // Required because electron likes to make it immutable sometimes.

+74 -15

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

···

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

     

       1
       1
       +
       import spacepack from "@moonlight-mod/wp/spacepack_spacepack";

     

       2
       2
        
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       3
       3
       +
       import Notices from "@moonlight-mod/wp/notices_notices";

     

       3
       4
        
       

     

       4
       4
       -
       function checkForUpdates() {

     

       5
       5
       -
         if (

     

       6
       6
       -
           MoonbaseSettingsStore.newVersion != null ||

     

       7
       7
       -
           Object.keys(MoonbaseSettingsStore.updates).length > 0

     

       8
       8
       -
         ) {

     

       9
       9
       -
           MoonbaseSettingsStore.showUpdateNotice();

     

       10
       10
       -
           Dispatcher.dispatch({

     

       11
       11
       -
             type: "NOTICE_SHOW",

     

       12
       12
       -
             notice: { type: "__moonlight_updates" }

     

       5
       5
       +
       // FIXME: not indexed as importable

     

       6
       6
       +
       const Constants = spacepack.require("discord/Constants");

     

       7
       7
       +
       const UserSettingsSections = spacepack.findObjectFromKey(

     

       8
       8
       +
         Constants,

     

       9
       9
       +
         "APPEARANCE_THEME_PICKER"

     

       10
       10
       +
       );

     

       11
       11
       +
       

     

       12
       12
       +
       function plural(str: string, num: number) {

     

       13
       13
       +
         return `${str}${num > 1 ? "s" : ""}`;

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       function listener() {

     

       17
       17
       +
         if (MoonbaseSettingsStore.shouldShowNotice) {

     

       18
       18
       +
           // @ts-expect-error epic type fail

     

       19
       19
       +
           MoonbaseSettingsStore.removeChangeListener(listener);

     

       20
       20
       +
       

     

       21
       21
       +
           const version = MoonbaseSettingsStore.newVersion;

     

       22
       22
       +
           const extensionUpdateCount = Object.keys(

     

       23
       23
       +
             MoonbaseSettingsStore.updates

     

       24
       24
       +
           ).length;

     

       25
       25
       +
           const hasExtensionUpdates = extensionUpdateCount > 0;

     

       26
       26
       +
       

     

       27
       27
       +
           let message;

     

       28
       28
       +
       

     

       29
       29
       +
           if (version != null) {

     

       30
       30
       +
             message =

     

       31
       31
       +
               moonlightNode.branch === "nightly"

     

       32
       32
       +
                 ? `A new version of moonlight is available`

     

       33
       33
       +
                 : `moonlight ${version} is available`;

     

       34
       34
       +
           }

     

       35
       35
       +
       

     

       36
       36
       +
           if (hasExtensionUpdates) {

     

       37
       37
       +
             let concat = false;

     

       38
       38
       +
             if (message == null) {

     

       39
       39
       +
               message = "";

     

       40
       40
       +
             } else {

     

       41
       41
       +
               concat = true;

     

       42
       42
       +
               message += ", and ";

     

       43
       43
       +
             }

     

       44
       44
       +
             message += `${extensionUpdateCount} ${concat ? "" : "moonlight "}${plural(

     

       45
       45
       +
               "extension",

     

       46
       46
       +
               extensionUpdateCount

     

       47
       47
       +
             )} can be updated`;

     

       48
       48
       +
           }

     

       49
       49
       +
       

     

       50
       50
       +
           if (message != null) message += ".";

     

       51
       51
       +
       

     

       52
       52
       +
           Notices.addNotice({

     

       53
       53
       +
             element: message,

     

       54
       54
       +
             color: "moonbase-updates-notice",

     

       55
       55
       +
             buttons: hasExtensionUpdates

     

       56
       56
       +
               ? [

     

       57
       57
       +
                   {

     

       58
       58
       +
                     name: "Open Moonbase",

     

       59
       59
       +
                     onClick: () => {

     

       60
       60
       +
                       const { open } = spacepack.findByExports(

     

       61
       61
       +
                         "setSection",

     

       62
       62
       +
                         "clearSubsection"

     

       63
       63
       +
                       )[0].exports.Z;

     

       64
       64
       +
       

     

       65
       65
       +
                       // settings is lazy loaded thus lazily patched

     

       66
       66
       +
                       // FIXME: figure out a way to detect if settings has been opened

     

       67
       67
       +
                       //        alreadyjust so the transition isnt as jarring

     

       68
       68
       +
                       open(UserSettingsSections.ACCOUNT);

     

       69
       69
       +
                       setTimeout(() => open("moonbase", 0), 0);

     

       70
       70
       +
                       return true;

     

       71
       71
       +
                     }

     

       72
       72
       +
                   }

     

       73
       73
       +
                 ]

     

       74
       74
       +
               : []

     

       13
       75
        
           });

     

       14
       76
        
         }

     

       15
       15
       -
       

     

       16
       16
       -
         Dispatcher.unsubscribe("CONNECTION_OPEN", checkForUpdates);

     

       17
       17
       -
         Dispatcher.unsubscribe("CONNECTION_OPEN_SUPPLEMENTAL", checkForUpdates);

     

       18
       77
        
       }

     

       19
       78
        
       

     

       20
       20
       -
       Dispatcher.subscribe("CONNECTION_OPEN", checkForUpdates);

     

       21
       21
       -
       Dispatcher.subscribe("CONNECTION_OPEN_SUPPLEMENTAL", checkForUpdates);

     

       79
       79
       +
       // @ts-expect-error epic type fail

     

       80
       80
       +
       MoonbaseSettingsStore.addChangeListener(listener);

-95

packages/core-extensions/src/moonbase/webpackModules/updatesNotice.tsx

···

       1
       1
       -
       import React from "@moonlight-mod/wp/react";

     

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

     

       3
       3
       -
       import * as Components from "@moonlight-mod/wp/discord/components/common/index";

     

       4
       4
       -
       import { useStateFromStoresObject } from "@moonlight-mod/wp/discord/packages/flux";

     

       5
       5
       -
       import spacepack from "@moonlight-mod/wp/spacepack_spacepack";

     

       6
       6
       -
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       7
       7
       -
       

     

       8
       8
       -
       // FIXME: not indexed as importable

     

       9
       9
       -
       const Constants = spacepack.require("discord/Constants");

     

       10
       10
       -
       const UserSettingsSections = spacepack.findObjectFromKey(

     

       11
       11
       -
         Constants,

     

       12
       12
       -
         "APPEARANCE_THEME_PICKER"

     

       13
       13
       -
       );

     

       14
       14
       -
       

     

       15
       15
       -
       // FIXME: types

     

       16
       16
       -
       const { Notice, NoticeCloseButton, PrimaryCTANoticeButton } = Components;

     

       17
       17
       -
       

     

       18
       18
       -
       const { open } = spacepack.findByExports("setSection", "clearSubsection")[0]

     

       19
       19
       -
         .exports.Z;

     

       20
       20
       -
       

     

       21
       21
       -
       function dismiss() {

     

       22
       22
       -
         MoonbaseSettingsStore.dismissUpdateNotice();

     

       23
       23
       -
         Dispatcher.dispatch({

     

       24
       24
       -
           type: "NOTICE_DISMISS"

     

       25
       25
       -
         });

     

       26
       26
       -
       }

     

       27
       27
       -
       

     

       28
       28
       -
       function openMoonbase() {

     

       29
       29
       -
         dismiss();

     

       30
       30
       -
         // settings is lazy loaded thus lazily patched

     

       31
       31
       -
         // FIXME: figure out a way to detect if settings has been opened already

     

       32
       32
       -
         //        just so the transition isnt as jarring

     

       33
       33
       -
         open(UserSettingsSections.ACCOUNT);

     

       34
       34
       -
         setTimeout(() => open("moonbase", 0), 0);

     

       35
       35
       -
       }

     

       36
       36
       -
       

     

       37
       37
       -
       function plural(str: string, num: number) {

     

       38
       38
       -
         return `${str}${num > 1 ? "s" : ""}`;

     

       39
       39
       -
       }

     

       40
       40
       -
       

     

       41
       41
       -
       export default function MoonbaseUpdatesNotice() {

     

       42
       42
       -
         const { version, extensionUpdateCount } = useStateFromStoresObject(

     

       43
       43
       -
           [MoonbaseSettingsStore],

     

       44
       44
       -
           () => ({

     

       45
       45
       -
             version: MoonbaseSettingsStore.newVersion,

     

       46
       46
       -
             extensionUpdateCount: Object.keys(MoonbaseSettingsStore.updates).length

     

       47
       47
       -
           })

     

       48
       48
       -
         );

     

       49
       49
       -
         const hasExtensionUpdates = extensionUpdateCount > 0;

     

       50
       50
       -
       

     

       51
       51
       -
         let message;

     

       52
       52
       -
       

     

       53
       53
       -
         if (version != null) {

     

       54
       54
       -
           message =

     

       55
       55
       -
             moonlightNode.branch === "nightly"

     

       56
       56
       -
               ? `A new version of moonlight is available`

     

       57
       57
       -
               : `moonlight ${version} is available`;

     

       58
       58
       -
         }

     

       59
       59
       -
       

     

       60
       60
       -
         if (hasExtensionUpdates) {

     

       61
       61
       -
           let concat = false;

     

       62
       62
       -
           if (message == null) {

     

       63
       63
       -
             message = "";

     

       64
       64
       -
           } else {

     

       65
       65
       -
             concat = true;

     

       66
       66
       -
             message += ", and ";

     

       67
       67
       -
           }

     

       68
       68
       -
           message += `${extensionUpdateCount} ${concat ? "" : "moonlight "}${plural(

     

       69
       69
       -
             "extension",

     

       70
       70
       -
             extensionUpdateCount

     

       71
       71
       -
           )} can be updated`;

     

       72
       72
       -
         }

     

       73
       73
       -
       

     

       74
       74
       -
         if (message != null) message += ".";

     

       75
       75
       -
       

     

       76
       76
       -
         let openButton;

     

       77
       77
       -
       

     

       78
       78
       -
         if (hasExtensionUpdates)

     

       79
       79
       -
           openButton = (

     

       80
       80
       -
             <PrimaryCTANoticeButton

     

       81
       81
       -
               onClick={openMoonbase}

     

       82
       82
       -
               noticeType="__moonlight_updates"

     

       83
       83
       -
             >

     

       84
       84
       -
               Open Moonbase

     

       85
       85
       -
             </PrimaryCTANoticeButton>

     

       86
       86
       -
           );

     

       87
       87
       -
       

     

       88
       88
       -
         return (

     

       89
       89
       -
           <Notice color="moonbase-updates-notice">

     

       90
       90
       -
             <NoticeCloseButton onClick={dismiss} noticeType="__moonlight_updates" />

     

       91
       91
       -
             {message}

     

       92
       92
       -
             {openButton}

     

       93
       93
       -
           </Notice>

     

       94
       94
       -
         );

     

       95
       95
       -
       }

+46

packages/core-extensions/src/notices/index.ts

···

       1
       1
       +
       import type { ExtensionWebpackModule, Patch } from "@moonlight-mod/types";

     

       2
       2
       +
       

     

       3
       3
       +
       export const patches: Patch[] = [

     

       4
       4
       +
         {

     

       5
       5
       +
           find: ".GUILD_RAID_NOTIFICATION:",

     

       6
       6
       +
           replace: {

     

       7
       7
       +
             match:

     

       8
       8
       +
               /(?<=return(\(0,.\.jsx\))\(.+?\);)case .{1,2}\..{1,3}\.GUILD_RAID_NOTIFICATION:/,

     

       9
       9
       +
             replacement: (orig, createElement) =>

     

       10
       10
       +
               `case "__moonlight_notice":return${createElement}(require("notices_component").default,{});${orig}`

     

       11
       11
       +
           }

     

       12
       12
       +
         },

     

       13
       13
       +
         {

     

       14
       14
       +
           find: '"NoticeStore"',

     

       15
       15
       +
           replace: [

     

       16
       16
       +
             {

     

       17
       17
       +
               match: /\[.{1,2}\..{1,3}\.CONNECT_SPOTIFY\]:{/,

     

       18
       18
       +
               replacement: (orig: string) =>

     

       19
       19
       +
                 `__moonlight_notice:{predicate:()=>require("notices_notices").default.shouldShowNotice()},${orig}`

     

       20
       20
       +
             },

     

       21
       21
       +
             {

     

       22
       22
       +
               match: /=\[(.{1,2}\..{1,3}\.QUARANTINED,)/g,

     

       23
       23
       +
               replacement: (_, orig) => `=["__moonlight_notice",${orig}`

     

       24
       24
       +
             }

     

       25
       25
       +
           ]

     

       26
       26
       +
         }

     

       27
       27
       +
       ];

     

       28
       28
       +
       

     

       29
       29
       +
       export const webpackModules: Record<string, ExtensionWebpackModule> = {

     

       30
       30
       +
         notices: {

     

       31
       31
       +
           dependencies: [

     

       32
       32
       +
             { id: "discord/packages/flux" },

     

       33
       33
       +
             { id: "discord/Dispatcher" }

     

       34
       34
       +
           ]

     

       35
       35
       +
         },

     

       36
       36
       +
       

     

       37
       37
       +
         component: {

     

       38
       38
       +
           dependencies: [

     

       39
       39
       +
             { id: "react" },

     

       40
       40
       +
             { id: "discord/Dispatcher" },

     

       41
       41
       +
             { id: "discord/components/common/index" },

     

       42
       42
       +
             { id: "discord/packages/flux" },

     

       43
       43
       +
             { ext: "notices", id: "notices" }

     

       44
       44
       +
           ]

     

       45
       45
       +
         }

     

       46
       46
       +
       };

+10

packages/core-extensions/src/notices/manifest.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "id": "notices",

     

       3
       3
       +
         "apiLevel": 2,

     

       4
       4
       +
         "meta": {

     

       5
       5
       +
           "name": "Notices",

     

       6
       6
       +
           "tagline": "An API for adding notices at the top of the page",

     

       7
       7
       +
           "authors": ["Cynosphere", "NotNite"],

     

       8
       8
       +
           "tags": ["library"]

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+56

packages/core-extensions/src/notices/webpackModules/component.tsx

···

       1
       1
       +
       import React from "@moonlight-mod/wp/react";

     

       2
       2
       +
       import Dispatcher from "@moonlight-mod/wp/discord/Dispatcher";

     

       3
       3
       +
       import * as Components from "@moonlight-mod/wp/discord/components/common/index";

     

       4
       4
       +
       import { useStateFromStoresObject } from "@moonlight-mod/wp/discord/packages/flux";

     

       5
       5
       +
       import NoticesStore from "@moonlight-mod/wp/notices_notices";

     

       6
       6
       +
       import type { Notice } from "@moonlight-mod/types/coreExtensions/notices";

     

       7
       7
       +
       

     

       8
       8
       +
       // FIXME: types

     

       9
       9
       +
       const { Notice, NoticeCloseButton, PrimaryCTANoticeButton } = Components;

     

       10
       10
       +
       

     

       11
       11
       +
       function popAndDismiss(notice: Notice) {

     

       12
       12
       +
         NoticesStore.popNotice();

     

       13
       13
       +
         if (notice?.onDismiss) {

     

       14
       14
       +
           notice.onDismiss();

     

       15
       15
       +
         }

     

       16
       16
       +
         if (!NoticesStore.shouldShowNotice()) {

     

       17
       17
       +
           Dispatcher.dispatch({

     

       18
       18
       +
             type: "NOTICE_DISMISS"

     

       19
       19
       +
           });

     

       20
       20
       +
         }

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       export default function UpdateNotice() {

     

       24
       24
       +
         const { notice } = useStateFromStoresObject([NoticesStore], () => ({

     

       25
       25
       +
           notice: NoticesStore.getCurrentNotice()

     

       26
       26
       +
         }));

     

       27
       27
       +
       

     

       28
       28
       +
         if (notice == null) return <></>;

     

       29
       29
       +
       

     

       30
       30
       +
         return (

     

       31
       31
       +
           <Notice color={notice.color}>

     

       32
       32
       +
             {notice.element}

     

       33
       33
       +
       

     

       34
       34
       +
             {(notice.showClose ?? true) && (

     

       35
       35
       +
               <NoticeCloseButton

     

       36
       36
       +
                 onClick={() => popAndDismiss(notice)}

     

       37
       37
       +
                 noticeType="__moonlight_notice"

     

       38
       38
       +
               />

     

       39
       39
       +
             )}

     

       40
       40
       +
       

     

       41
       41
       +
             {(notice.buttons ?? []).map((button) => (

     

       42
       42
       +
               <PrimaryCTANoticeButton

     

       43
       43
       +
                 key={button.name}

     

       44
       44
       +
                 onClick={() => {

     

       45
       45
       +
                   if (button.onClick()) {

     

       46
       46
       +
                     popAndDismiss(notice);

     

       47
       47
       +
                   }

     

       48
       48
       +
                 }}

     

       49
       49
       +
                 noticeType="__moonlight_notice"

     

       50
       50
       +
               >

     

       51
       51
       +
                 {button.name}

     

       52
       52
       +
               </PrimaryCTANoticeButton>

     

       53
       53
       +
             ))}

     

       54
       54
       +
           </Notice>

     

       55
       55
       +
         );

     

       56
       56
       +
       }

+58

packages/core-extensions/src/notices/webpackModules/notices.ts

···

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

     

       2
       2
       +
       import Dispatcher from "@moonlight-mod/wp/discord/Dispatcher";

     

       3
       3
       +
       import type {

     

       4
       4
       +
         Notice,

     

       5
       5
       +
         Notices

     

       6
       6
       +
       } from "@moonlight-mod/types/coreExtensions/notices";

     

       7
       7
       +
       

     

       8
       8
       +
       // very lazy way of doing this, FIXME

     

       9
       9
       +
       let open = false;

     

       10
       10
       +
       

     

       11
       11
       +
       class NoticesStore extends Store<any> {

     

       12
       12
       +
         private notices: Notice[] = [];

     

       13
       13
       +
       

     

       14
       14
       +
         constructor() {

     

       15
       15
       +
           super(Dispatcher);

     

       16
       16
       +
         }

     

       17
       17
       +
       

     

       18
       18
       +
         addNotice(notice: Notice) {

     

       19
       19
       +
           this.notices.push(notice);

     

       20
       20
       +
           if (open && this.notices.length !== 0) {

     

       21
       21
       +
             Dispatcher.dispatch({

     

       22
       22
       +
               type: "NOTICE_SHOW",

     

       23
       23
       +
               notice: { type: "__moonlight_notice" }

     

       24
       24
       +
             });

     

       25
       25
       +
           }

     

       26
       26
       +
           this.emitChange();

     

       27
       27
       +
         }

     

       28
       28
       +
       

     

       29
       29
       +
         popNotice() {

     

       30
       30
       +
           this.notices.shift();

     

       31
       31
       +
           this.emitChange();

     

       32
       32
       +
         }

     

       33
       33
       +
       

     

       34
       34
       +
         getCurrentNotice() {

     

       35
       35
       +
           return this.notices.length > 0 ? this.notices[0] : null;

     

       36
       36
       +
         }

     

       37
       37
       +
       

     

       38
       38
       +
         shouldShowNotice() {

     

       39
       39
       +
           return this.notices.length > 0;

     

       40
       40
       +
         }

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       const store: Notices = new NoticesStore();

     

       44
       44
       +
       

     

       45
       45
       +
       function showNotice() {

     

       46
       46
       +
         open = true;

     

       47
       47
       +
         if (store.shouldShowNotice()) {

     

       48
       48
       +
           Dispatcher.dispatch({

     

       49
       49
       +
             type: "NOTICE_SHOW",

     

       50
       50
       +
             notice: { type: "__moonlight_notice" }

     

       51
       51
       +
           });

     

       52
       52
       +
         }

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       Dispatcher.subscribe("CONNECTION_OPEN", showNotice);

     

       56
       56
       +
       Dispatcher.subscribe("CONNECTION_OPEN_SUPPLEMENTAL", showNotice);

     

       57
       57
       +
       

     

       58
       58
       +
       export default store;

packages/types/src/coreExtensions.ts

···

       2
       2
        
       export * as Settings from "./coreExtensions/settings";

     

       3
       3
        
       export * as Markdown from "./coreExtensions/markdown";

     

       4
       4
        
       export * as ContextMenu from "./coreExtensions/contextMenu";

     

       5
       5
       +
       export * as Notices from "./coreExtensions/notices";

+21

packages/types/src/coreExtensions/notices.ts

···

       1
       1
       +
       import type { Store } from "@moonlight-mod/mappings/discord/packages/flux";

     

       2
       2
       +
       

     

       3
       3
       +
       export type NoticeButton = {

     

       4
       4
       +
         name: string;

     

       5
       5
       +
         onClick: () => boolean; // return true to dismiss the notice after the button is clicked

     

       6
       6
       +
       };

     

       7
       7
       +
       

     

       8
       8
       +
       export type Notice = {

     

       9
       9
       +
         element: React.ReactNode;

     

       10
       10
       +
         color?: string;

     

       11
       11
       +
         showClose?: boolean;

     

       12
       12
       +
         buttons?: NoticeButton[];

     

       13
       13
       +
         onDismiss?: () => void;

     

       14
       14
       +
       };

     

       15
       15
       +
       

     

       16
       16
       +
       export type Notices = Store<any> & {

     

       17
       17
       +
         addNotice: (notice: Notice) => void;

     

       18
       18
       +
         popNotice: () => void;

     

       19
       19
       +
         getCurrentNotice: () => Notice | null;

     

       20
       20
       +
         shouldShowNotice: () => boolean;

     

       21
       21
       +
       };

packages/types/src/discord/require.ts

···

       2
       2
        
       import { Markdown } from "../coreExtensions/markdown";

     

       3
       3
        
       import { Settings } from "../coreExtensions/settings";

     

       4
       4
        
       import { Spacepack } from "../coreExtensions/spacepack";

     

       5
       5
       +
       import { Notices } from "../coreExtensions/notices";

     

       5
       6
        
       

     

       6
       7
        
       declare function WebpackRequire(id: string): any;

     

       7
       8
        
       

     
···

       9
       10
        
       declare function WebpackRequire(id: "contextMenu_contextMenu"): ContextMenu;

     

       10
       11
        
       

     

       11
       12
        
       declare function WebpackRequire(id: "markdown_markdown"): Markdown;

     

       13
       13
       +
       

     

       14
       14
       +
       declare function WebpackRequire(id: "notices_notices"): Notices;

     

       12
       15
        
       

     

       13
       16
        
       declare function WebpackRequire(id: "settings_settings"): {

     

       14
       17
        
         Settings: Settings;

packages/types/src/import.d.ts

···

       17
       17
        
         export = Markdown;

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
       +
       declare module "@moonlight-mod/wp/notices_notices" {

     

       21
       21
       +
         import { CoreExtensions } from "@moonlight-mod/types";

     

       22
       22
       +
         const Notices: CoreExtensions.Notices.Notices;

     

       23
       23
       +
         export = Notices;

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       20
       26
        
       declare module "@moonlight-mod/wp/settings_settings" {

     

       21
       27
        
         import { CoreExtensions } from "@moonlight-mod/types";

     

       22
       28
        
         export const Settings: CoreExtensions.Settings.Settings;