commit 8ae8d9fcd16c87449ce38fe1da0b6c9915f45278 · notnite.com/moonlight

+9 -7

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

···

       1
       1
        
       import {

     

       2
       2
        
         Config,

     

       3
       3
       +
         constants,

     

       3
       4
        
         ExtensionLoadSource,

     

       4
       5
        
         MoonlightBranch

     

       5
       6
        
       } from "@moonlight-mod/types";

     
···

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

     

       152
       153
        
                 try {

     

       153
       154
        
                   for (const ext of exts) {

     

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

     

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

     

       156
       156
       -
       

     

       157
       155
        
                     const uniqueId = this.extensionIndex++;

     

       158
       156
        
                     const extensionData = {

     

       159
       157
        
                       id: ext.id,

     
···

       163
       161
        
                       state: ExtensionState.NotDownloaded

     

       164
       162
        
                     };

     

       165
       163
        
       

     

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

     

       164
       164
       +
                     const apiLevel = ext.apiLevel ?? 1;

     

       165
       165
       +
                     if (apiLevel !== constants.apiLevel) continue;

     

       166
       166
       +
       

     

       167
       167
       +
                     const existing = this.getExisting(extensionData);

     

       168
       168
       +
                     if (existing != null) {

     

       167
       169
        
                       // Make sure the download URL is properly updated

     

       168
       170
        
                       for (const [id, e] of Object.entries(this.extensions)) {

     

       169
       171
        
                         if (e.id === ext.id && e.source.url === repo) {

     
···

       176
       178
        
                       }

     

       177
       179
        
       

     

       178
       180
        
                       if (this.hasUpdate(extensionData)) {

     

       179
       179
       -
                         this.updates[uniqueId] = {

     

       181
       181
       +
                         this.updates[existing.uniqueId] = {

     

       180
       182
        
                           version: ext.version!,

     

       181
       183
        
                           download: ext.download

     

       182
       184
        
                         };

     
···

       206
       208
        
             });

     

       207
       209
        
         }

     

       208
       210
        
       

     

       209
       209
       -
         private alreadyExists(ext: MoonbaseExtension) {

     

       210
       210
       -
           return Object.values(this.extensions).some(

     

       211
       211
       +
         private getExisting(ext: MoonbaseExtension) {

     

       212
       212
       +
           return Object.values(this.extensions).find(

     

       211
       213
        
             (e) => e.id === ext.id && e.source.url === ext.source.url

     

       212
       214
        
           );

     

       213
       215
        
         }

-4

packages/core/src/extension.ts

···

       111
       111
        
             const manifest: ExtensionManifest = JSON.parse(

     

       112
       112
        
               await fs.readFile(manifestPath)

     

       113
       113
        
             );

     

       114
       114
       -
             const level = manifest.apiLevel ?? 1;

     

       115
       115
       -
             if (level !== constants.apiLevel) {

     

       116
       116
       -
               continue;

     

       117
       117
       -
             }

     

       118
       114
        
       

     

       119
       115
        
             const webPath = fs.join(dir, "index.js");

     

       120
       116
        
             const nodePath = fs.join(dir, "node.js");

+4 -1

packages/core/src/extension/loader.ts

···

       2
       2
        
         ExtensionWebExports,

     

       3
       3
        
         DetectedExtension,

     

       4
       4
        
         ProcessedExtensions,

     

       5
       5
       -
         WebpackModuleFunc

     

       5
       5
       +
         WebpackModuleFunc,

     

       6
       6
       +
         constants

     

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

     

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

     

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

     
···

       121
       122
        
       export async function loadExtensions(

     

       122
       123
        
         exts: DetectedExtension[]

     

       123
       124
        
       ): Promise<ProcessedExtensions> {

     

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

     

       126
       126
       +
       

     

       124
       127
        
         const config = await readConfig();

     

       125
       128
        
         const items = exts

     

       126
       129
        
           .map((ext) => {