commit 078d1e288b0e9696c90bcaba121983f9050b6f95 · notnite.com/moonlight

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

···

       1
       1
       +
       import { ExtensionCompat } from "@moonlight-mod/core/extension/loader";

     

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

     

       2
       3
        
       

     

       3
       4
        
       export type MoonbaseNatives = {

     
···

       30
       31
        
         manifest: ExtensionManifest | RepositoryManifest;

     

       31
       32
        
         source: DetectedExtension["source"];

     

       32
       33
        
         state: ExtensionState;

     

       34
       34
       +
         compat: ExtensionCompat;

     

       35
       35
       +
         hasUpdate: boolean;

     

       33
       36
        
       };

+37 -9

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

···

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

     

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

     

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

     

       2
       2
       +
       import {

     

       3
       3
       +
         ExtensionState,

     

       4
       4
       +
         MoonbaseExtension,

     

       5
       5
       +
         MoonbaseNatives,

     

       6
       6
       +
         RepositoryManifest

     

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

     

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

     

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

     

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

     

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

     

       12
       12
       +
       import {

     

       13
       13
       +
         checkExtensionCompat,

     

       14
       14
       +
         ExtensionCompat

     

       15
       15
       +
       } from "@moonlight-mod/core/extension/loader";

     

       7
       16
        
       

     

       8
       17
        
       const logger = moonlight.getLogger("moonbase");

     

       9
       18
        
       

     
···

       23
       32
        
         shouldShowNotice: boolean;

     

       24
       33
        
       

     

       25
       34
        
         extensions: { [id: number]: MoonbaseExtension };

     

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

     

       35
       35
       +
         updates: {

     

       36
       36
       +
           [id: number]: {

     

       37
       37
       +
             version: string;

     

       38
       38
       +
             download: string;

     

       39
       39
       +
             updateManifest: RepositoryManifest;

     

       40
       40
       +
           };

     

       41
       41
       +
         };

     

       27
       42
        
       

     

       28
       43
        
         constructor() {

     

       29
       44
        
           super(Dispatcher);

     
···

       48
       63
        
               uniqueId,

     

       49
       64
        
               state: moonlight.enabledExtensions.has(ext.id)

     

       50
       65
        
                 ? ExtensionState.Enabled

     

       51
       51
       -
                 : ExtensionState.Disabled

     

       66
       66
       +
                 : ExtensionState.Disabled,

     

       67
       67
       +
               compat: checkExtensionCompat(ext.manifest),

     

       68
       68
       +
               hasUpdate: false

     

       52
       69
        
             };

     

       53
       70
        
           }

     

       54
       71
        
       

     
···

       64
       81
        
                       uniqueId,

     

       65
       82
        
                       manifest: ext,

     

       66
       83
        
                       source: { type: ExtensionLoadSource.Normal, url: repo },

     

       67
       67
       -
                       state: ExtensionState.NotDownloaded

     

       84
       84
       +
                       state: ExtensionState.NotDownloaded,

     

       85
       85
       +
                       compat: ExtensionCompat.Compatible,

     

       86
       86
       +
                       hasUpdate: false

     

       68
       87
        
                     };

     

       69
       88
        
       

     

       70
       70
       -
                     const apiLevel = ext.apiLevel ?? 1;

     

       71
       71
       -
                     if (apiLevel !== constants.apiLevel) continue;

     

       89
       89
       +
                     // Don't present incompatible updates

     

       90
       90
       +
                     if (checkExtensionCompat(ext) !== ExtensionCompat.Compatible)

     

       91
       91
       +
                       continue;

     

       72
       92
        
       

     

       73
       93
        
                     const existing = this.getExisting(extensionData);

     

       74
       94
        
                     if (existing != null) {

     
···

       86
       106
        
                       if (this.hasUpdate(extensionData)) {

     

       87
       107
        
                         this.updates[existing.uniqueId] = {

     

       88
       108
        
                           version: ext.version!,

     

       89
       89
       -
                           download: ext.download

     

       109
       109
       +
                           download: ext.download,

     

       110
       110
       +
                           updateManifest: ext

     

       90
       111
        
                         };

     

       112
       112
       +
                         existing.hasUpdate = true;

     

       91
       113
        
                       }

     

       92
       114
        
       

     

       93
       115
        
                       continue;

     
···

       253
       275
        
       

     

       254
       276
        
           this.installing = true;

     

       255
       277
        
           try {

     

       256
       256
       -
             const url = this.updates[uniqueId]?.download ?? ext.manifest.download;

     

       278
       278
       +
             const update = this.updates[uniqueId];

     

       279
       279
       +
             const url = update?.download ?? ext.manifest.download;

     

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

     

       258
       281
        
             if (ext.state === ExtensionState.NotDownloaded) {

     

       259
       282
        
               this.extensions[uniqueId].state = ExtensionState.Disabled;

     

       260
       283
        
             }

     

       284
       284
       +
       

     

       285
       285
       +
             if (update != null)

     

       286
       286
       +
               this.extensions[uniqueId].compat = checkExtensionCompat(

     

       287
       287
       +
                 update.updateManifest

     

       288
       288
       +
               );

     

       261
       289
        
       

     

       262
       290
        
             delete this.updates[uniqueId];

     

       263
       291
        
           } catch (e) {

+42 -18

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

···

       1
       1
        
       import { ExtensionState } from "../../../types";

     

       2
       2
        
       import { ExtensionLoadSource } from "@moonlight-mod/types";

     

       3
       3
       +
       import { ExtensionCompat } from "@moonlight-mod/core/extension/loader";

     

       3
       4
        
       

     

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

     

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

     
···

       36
       37
        
       const BuildOverrideClasses = spacepack.findByExports(

     

       37
       38
        
         "disabledButtonOverride"

     

       38
       39
        
       )[0].exports;

     

       40
       40
       +
       

     

       41
       41
       +
       const COMPAT_TEXT_MAP: Record<ExtensionCompat, string> = {

     

       42
       42
       +
         [ExtensionCompat.Compatible]: "huh?",

     

       43
       43
       +
         [ExtensionCompat.InvalidApiLevel]: "Incompatible API level",

     

       44
       44
       +
         [ExtensionCompat.InvalidEnvironment]: "Incompatible platform"

     

       45
       45
       +
       };

     

       39
       46
        
       

     

       40
       47
        
       export default function ExtensionCard({ uniqueId }: { uniqueId: number }) {

     

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

     
···

       110
       117
        
                 justify={Flex.Justify.END}

     

       111
       118
        
               >

     

       112
       119
        
                 {ext.state === ExtensionState.NotDownloaded ? (

     

       113
       113
       -
                   <Button

     

       114
       114
       -
                     color={Button.Colors.BRAND}

     

       115
       115
       -
                     submitting={busy}

     

       116
       116
       -
                     disabled={conflicting}

     

       117
       117
       -
                     onClick={async () => {

     

       118
       118
       -
                       await installWithDependencyPopup(uniqueId);

     

       119
       119
       -
                     }}

     

       120
       120
       +
                   <Tooltip

     

       121
       121
       +
                     text={COMPAT_TEXT_MAP[ext.compat]}

     

       122
       122
       +
                     shouldShow={ext.compat !== ExtensionCompat.Compatible}

     

       120
       123
        
                   >

     

       121
       121
       -
                     Install

     

       122
       122
       -
                   </Button>

     

       124
       124
       +
                     {(props: any) => (

     

       125
       125
       +
                       <Button

     

       126
       126
       +
                         {...props}

     

       127
       127
       +
                         color={Button.Colors.BRAND}

     

       128
       128
       +
                         submitting={busy}

     

       129
       129
       +
                         disabled={

     

       130
       130
       +
                           ext.compat !== ExtensionCompat.Compatible || conflicting

     

       131
       131
       +
                         }

     

       132
       132
       +
                         onClick={async () => {

     

       133
       133
       +
                           await installWithDependencyPopup(uniqueId);

     

       134
       134
       +
                         }}

     

       135
       135
       +
                       >

     

       136
       136
       +
                         Install

     

       137
       137
       +
                       </Button>

     

       138
       138
       +
                     )}

     

       139
       139
       +
                   </Tooltip>

     

       123
       140
        
                 ) : (

     

       124
       141
        
                   <div

     

       125
       142
        
                     // too lazy to learn how <Flex /> works lmao

     
···

       162
       179
        
                     )}

     

       163
       180
        
       

     

       164
       181
        
                     <FormSwitch

     

       165
       165
       -
                       value={enabled || implicitlyEnabled}

     

       166
       166
       -
                       disabled={implicitlyEnabled}

     

       182
       182
       +
                       value={

     

       183
       183
       +
                         ext.compat === ExtensionCompat.Compatible &&

     

       184
       184
       +
                         (enabled || implicitlyEnabled)

     

       185
       185
       +
                       }

     

       186
       186
       +
                       disabled={

     

       187
       187
       +
                         implicitlyEnabled || ext.compat !== ExtensionCompat.Compatible

     

       188
       188
       +
                       }

     

       167
       189
        
                       hideBorder={true}

     

       168
       190
        
                       style={{ marginBottom: "0px" }}

     

       169
       191
        
                       tooltipNote={

     

       170
       170
       -
                         implicitlyEnabled

     

       171
       171
       -
                           ? `This extension is a dependency of the following enabled extension${

     

       172
       172
       -
                               enabledDependants.length > 1 ? "s" : ""

     

       173
       173
       -
                             }: ${enabledDependants

     

       174
       174
       -
                               .map((a) => a.manifest.meta?.name ?? a.id)

     

       175
       175
       -
                               .join(", ")}`

     

       176
       176
       -
                           : undefined

     

       192
       192
       +
                         ext.compat !== ExtensionCompat.Compatible

     

       193
       193
       +
                           ? COMPAT_TEXT_MAP[ext.compat]

     

       194
       194
       +
                           : implicitlyEnabled

     

       195
       195
       +
                             ? `This extension is a dependency of the following enabled extension${

     

       196
       196
       +
                                 enabledDependants.length > 1 ? "s" : ""

     

       197
       197
       +
                               }: ${enabledDependants

     

       198
       198
       +
                                 .map((a) => a.manifest.meta?.name ?? a.id)

     

       199
       199
       +
                                 .join(", ")}`

     

       200
       200
       +
                             : undefined

     

       177
       201
        
                       }

     

       178
       202
        
                       onChange={() => {

     

       179
       203
        
                         setRestartNeeded(true);

+9 -2

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

···

       24
       24
        
         Enabled = 1 << 3,

     

       25
       25
        
         Disabled = 1 << 4,

     

       26
       26
        
         Installed = 1 << 5,

     

       27
       27
       -
         Repository = 1 << 6

     

       27
       27
       +
         Repository = 1 << 6,

     

       28
       28
       +
         Incompatible = 1 << 7

     

       28
       29
        
       }

     

       29
       29
       -
       export const defaultFilter = ~(~0 << 7);

     

       30
       30
       +
       export const defaultFilter = 127 as Filter;

     

       30
       31
        
       

     

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

     

       32
       33
        
       const SortMenuClasses = spacepack.findByCode("container:", "clearText:")[0]

     
···

       130
       131
        
                 />

     

       131
       132
        
               </MenuGroup>

     

       132
       133
        
               <MenuGroup>

     

       134
       134
       +
                 <MenuCheckboxItem

     

       135
       135
       +
                   id="l-incompatible"

     

       136
       136
       +
                   label="Show incompatible"

     

       137
       137
       +
                   checked={filter & Filter.Incompatible}

     

       138
       138
       +
                   action={() => toggleFilter(Filter.Incompatible)}

     

       139
       139
       +
                 />

     

       133
       140
        
                 <MenuItem

     

       134
       141
        
                   id="reset-all"

     

       135
       142
        
                   className={SortMenuClasses.clearText}

+5 -1

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

···

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

     

       9
       9
        
       

     

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

     

       11
       11
       +
       import { ExtensionCompat } from "core/src/extension/loader";

     

       11
       12
        
       

     

       12
       13
        
       const SearchBar: any = Object.values(

     

       13
       14
        
         spacepack.findByCode("Messages.SEARCH", "hideSearchIcon")[0].exports

     
···

       73
       74
        
                 ext.state !== ExtensionState.NotDownloaded) ||

     

       74
       75
        
               (!(filter & Filter.Repository) &&

     

       75
       76
        
                 ext.state === ExtensionState.NotDownloaded)

     

       76
       76
       -
             )

     

       77
       77
       +
             ) &&

     

       78
       78
       +
             (filter & Filter.Incompatible ||

     

       79
       79
       +
               ext.compat === ExtensionCompat.Compatible ||

     

       80
       80
       +
               (ext.compat === ExtensionCompat.InvalidApiLevel && ext.hasUpdate))

     

       77
       81
        
         );

     

       78
       82
        
       

     

       79
       83
        
         return (

+33 -2

packages/core/src/extension/loader.ts

···

       3
       3
        
         DetectedExtension,

     

       4
       4
        
         ProcessedExtensions,

     

       5
       5
        
         WebpackModuleFunc,

     

       6
       6
       -
         constants

     

       6
       6
       +
         constants,

     

       7
       7
       +
         ExtensionManifest,

     

       8
       8
       +
         ExtensionEnvironment

     

       7
       9
        
       } from "@moonlight-mod/types";

     

       8
       10
        
       import { readConfig } from "../config";

     

       9
       11
        
       import Logger from "../util/logger";

     
···

       105
       107
        
         }

     

       106
       108
        
       }

     

       107
       109
        
       

     

       110
       110
       +
       export enum ExtensionCompat {

     

       111
       111
       +
         Compatible,

     

       112
       112
       +
         InvalidApiLevel,

     

       113
       113
       +
         InvalidEnvironment

     

       114
       114
       +
       }

     

       115
       115
       +
       

     

       116
       116
       +
       export function checkExtensionCompat(

     

       117
       117
       +
         manifest: ExtensionManifest

     

       118
       118
       +
       ): ExtensionCompat {

     

       119
       119
       +
         let environment;

     

       120
       120
       +
         webTarget: {

     

       121
       121
       +
           environment = ExtensionEnvironment.Web;

     

       122
       122
       +
         }

     

       123
       123
       +
         nodeTarget: {

     

       124
       124
       +
           environment = ExtensionEnvironment.Desktop;

     

       125
       125
       +
         }

     

       126
       126
       +
       

     

       127
       127
       +
         if (manifest.apiLevel !== constants.apiLevel)

     

       128
       128
       +
           return ExtensionCompat.InvalidApiLevel;

     

       129
       129
       +
         if (

     

       130
       130
       +
           (manifest.environment ?? "both") !== "both" &&

     

       131
       131
       +
           manifest.environment !== environment

     

       132
       132
       +
         )

     

       133
       133
       +
           return ExtensionCompat.InvalidEnvironment;

     

       134
       134
       +
         return ExtensionCompat.Compatible;

     

       135
       135
       +
       }

     

       136
       136
       +
       

     

       108
       137
        
       /*

     

       109
       138
        
         This function resolves extensions and loads them, split into a few stages:

     

       110
       139
        
       

     
···

       122
       151
        
       export async function loadExtensions(

     

       123
       152
        
         exts: DetectedExtension[]

     

       124
       153
        
       ): Promise<ProcessedExtensions> {

     

       125
       125
       -
         exts = exts.filter((x) => x.manifest.apiLevel === constants.apiLevel);

     

       154
       154
       +
         exts = exts.filter(

     

       155
       155
       +
           (ext) => checkExtensionCompat(ext.manifest) === ExtensionCompat.Compatible

     

       156
       156
       +
         );

     

       126
       157
        
       

     

       127
       158
        
         const config = await readConfig();

     

       128
       159
        
         const items = exts

packages/types/src/extension.ts

···

       31
       31
        
         id: string;

     

       32
       32
        
         version?: string;

     

       33
       33
        
         apiLevel?: number;

     

       34
       34
       +
         environment?: ExtensionEnvironment;

     

       34
       35
        
       

     

       35
       36
        
         meta?: {

     

       36
       37
        
           name?: string;

     
···

       51
       52
        
         cors?: string[];

     

       52
       53
        
         blocked?: string[];

     

       53
       54
        
       };

     

       55
       55
       +
       

     

       56
       56
       +
       export enum ExtensionEnvironment {

     

       57
       57
       +
         Both = "both",

     

       58
       58
       +
         Desktop = "desktop",

     

       59
       59
       +
         Web = "web"

     

       60
       60
       +
       }

     

       54
       61
        
       

     

       55
       62
        
       export enum ExtensionLoadSource {

     

       56
       63
        
         Developer,