commit 85eaf51aac65eaad345086f612997cec0883fa37 · notnite.com/moonlight

+3 -10

packages/core/src/extension/loader.ts

···

       60
       60
        
             let idx = 0;

     

       61
       61
        
             for (const patch of exports.patches) {

     

       62
       62
        
               if (Array.isArray(patch.replace)) {

     

       63
       63
       -
                 for (const replacement of patch.replace) {

     

       64
       64
       -
                   const newPatch = Object.assign({}, patch, {

     

       65
       65
       -
                     replace: replacement

     

       66
       66
       -
                   });

     

       67
       67
       -
       

     

       68
       68
       -
                   registerPatch({ ...newPatch, ext: ext.id, id: idx });

     

       69
       69
       -
                   idx++;

     

       70
       70
       -
                 }

     

       63
       63
       +
                 registerPatch({ ...patch, ext: ext.id, id: idx });

     

       71
       64
        
               } else {

     

       72
       72
       -
                 registerPatch({ ...patch, ext: ext.id, id: idx });

     

       73
       73
       -
                 idx++;

     

       65
       65
       +
                 registerPatch({ ...patch, replace: [patch.replace], ext: ext.id, id: idx });

     

       74
       66
        
               }

     

       67
       67
       +
               idx++;

     

       75
       68
        
             }

     

       76
       69
        
           }

     

       77
       70

+43 -29

packages/core/src/patch.ts

···

       103
       103
        
       

     

       104
       104
        
         for (const [id, func] of Object.entries(entry)) {

     

       105
       105
        
           if (func.__moonlight === true) continue;

     

       106
       106
       -
           let moduleString = moduleCache[id];

     

       106
       106
       +
       

     

       107
       107
       +
           // Clone the module string so finds don't get messed up by other extensions

     

       108
       108
       +
           const origModuleString = moduleCache[id];

     

       109
       109
       +
           let moduleString = origModuleString;

     

       110
       110
       +
           const patchedStr = [];

     

       111
       111
       +
           const mappedName = moonlight.moonmap.modules[id];

     

       107
       112
        
       

     

       108
       113
        
           for (let i = 0; i < patches.length; i++) {

     

       109
       114
        
             const patch = patches[i];

     
···

       116
       121
        
               patch.find.lastIndex = 0;

     

       117
       122
        
             }

     

       118
       123
        
       

     

       119
       119
       -
             const match = testFind(moduleString, patch.find);

     

       124
       124
       +
             const match = testFind(origModuleString, patch.find) || patch.find === mappedName;

     

       120
       125
        
       

     

       121
       126
        
             // Global regexes apply to all modules

     

       122
       127
        
             const shouldRemove = typeof patch.find === "string" ? true : !patch.find.global;

     

       123
       128
        
       

     

       129
       129
       +
             let replaced = moduleString;

     

       130
       130
       +
             let hardFailed = false;

     

       124
       131
        
             if (match) {

     

       125
       125
       -
               // We ensured all arrays get turned into normal PatchReplace objects on register

     

       126
       126
       -
               const replace = patch.replace as PatchReplace;

     

       132
       132
       +
               // We ensured normal PatchReplace objects get turned into arrays on register

     

       133
       133
       +
               const replaces = patch.replace as PatchReplace[];

     

       127
       134
        
       

     

       128
       128
       -
               if (replace.type === undefined || replace.type === PatchReplaceType.Normal) {

     

       129
       129
       -
                 // tsc fails to detect the overloads for this, so I'll just do this

     

       130
       130
       -
                 // Verbose, but it works

     

       131
       131
       -
                 let replaced;

     

       132
       132
       -
                 if (typeof replace.replacement === "string") {

     

       133
       133
       -
                   replaced = moduleString.replace(replace.match, replace.replacement);

     

       134
       134
       -
                 } else {

     

       135
       135
       -
                   replaced = moduleString.replace(replace.match, replace.replacement);

     

       136
       136
       -
                 }

     

       135
       135
       +
               for (let i = 0; i < replaces.length; i++) {

     

       136
       136
       +
                 const replace = replaces[i];

     

       137
       137
       +
                 let patchId = `${patch.ext}#${patch.id}`;

     

       138
       138
       +
                 if (replaces.length > 1) patchId += `#${i}`;

     

       139
       139
       +
                 patchedStr.push(patchId);

     

       137
       140
        
       

     

       138
       138
       -
                 if (replaced === moduleString) {

     

       139
       139
       -
                   logger.warn("Patch replacement failed", id, patch);

     

       140
       140
       -
                   continue;

     

       141
       141
       -
                 }

     

       141
       141
       +
                 if (replace.type === undefined || replace.type === PatchReplaceType.Normal) {

     

       142
       142
       +
                   // tsc fails to detect the overloads for this, so I'll just do this

     

       143
       143
       +
                   // Verbose, but it works

     

       144
       144
       +
                   if (typeof replace.replacement === "string") {

     

       145
       145
       +
                     replaced = replaced.replace(replace.match, replace.replacement);

     

       146
       146
       +
                   } else {

     

       147
       147
       +
                     replaced = replaced.replace(replace.match, replace.replacement);

     

       148
       148
       +
                   }

     

       142
       149
        
       

     

       143
       143
       -
                 if (patchModule(id, `${patch.ext}#${patch.id}`, replaced)) {

     

       144
       144
       -
                   moduleString = replaced;

     

       150
       150
       +
                   if (replaced === moduleString) {

     

       151
       151
       +
                     logger.warn("Patch replacement failed", id, patch);

     

       152
       152
       +
                     if (patch.hardFail) {

     

       153
       153
       +
                       hardFailed = true;

     

       154
       154
       +
                       break;

     

       155
       155
       +
                     } else {

     

       156
       156
       +
                       continue;

     

       157
       157
       +
                     }

     

       158
       158
       +
                   }

     

       159
       159
       +
                 } else if (replace.type === PatchReplaceType.Module) {

     

       160
       160
       +
                   // Directly replace the module with a new one

     

       161
       161
       +
                   const newModule = replace.replacement(replaced);

     

       162
       162
       +
                   entry[id] = newModule;

     

       163
       163
       +
                   entry[id].__moonlight = true;

     

       164
       164
       +
                   replaced = replaced.toString().replace(/\n/g, "") + `//# sourceURL=Webpack-Module-${id}`;

     

       145
       165
        
                 }

     

       146
       146
       -
               } else if (replace.type === PatchReplaceType.Module) {

     

       147
       147
       -
                 // Directly replace the module with a new one

     

       148
       148
       -
                 const newModule = replace.replacement(moduleString);

     

       149
       149
       -
                 entry[id] = newModule;

     

       150
       150
       -
                 entry[id].__moonlight = true;

     

       151
       151
       -
                 moduleString = newModule.toString().replace(/\n/g, "") + `//# sourceURL=Webpack-Module-${id}`;

     

       152
       166
        
               }

     

       167
       167
       +
       

     

       168
       168
       +
               if (!hardFailed) moduleString = replaced;

     

       153
       169
        
       

     

       154
       170
        
               moonlight.unpatched.delete(patch);

     

       155
       155
       -
       

     

       156
       156
       -
               if (shouldRemove) {

     

       157
       157
       -
                 patches.splice(i--, 1);

     

       158
       158
       -
               }

     

       171
       171
       +
               if (shouldRemove) patches.splice(i--, 1);

     

       159
       172
        
             }

     

       160
       173
        
           }

     

       161
       174
        
       

     

       175
       175
       +
           patchModule(id, patchedStr.join(", "), moduleString);

     

       162
       176
        
           moduleCache[id] = moduleString;

     

       163
       177
        
       

     

       164
       178
        
           try {

packages/types/src/extension.ts

···

       108
       108
        
       export type Patch = {

     

       109
       109
        
         find: PatchMatch;

     

       110
       110
        
         replace: PatchReplace | PatchReplace[];

     

       111
       111
       +
         hardFail?: boolean; // if any patches fail, all fail

     

       111
       112
        
         prerequisite?: () => boolean;

     

       112
       113
        
       };

     

       113
       114