commit 2e0bede6931d50534603b5a981f33ac28f27453d · notnite.com/moonlight

+1 -1

packages/core-extensions/src/common/webpackModules/components.ts

···

       6
       6
        
       )[0].exports.default;

     

       7
       7
        
       const LegacyText = spacepack.findByCode(".selectable", ".colorStandard")[0]

     

       8
       8
        
         .exports.default;

     

       9
       9
       -
       const Flex = spacepack.findByCode(".flex" + "GutterSmall,")[0].exports.default;

     

       9
       9
       +
       const Flex = spacepack.findByCode(".flex" + "GutterSmall,")[0].exports.Flex;

     

       10
       10
        
       const CardClasses = spacepack.findByCode("card", "cardHeader", "inModal")[0]

     

       11
       11
        
         .exports;

     

       12
       12
        
       const ControlClasses = spacepack.findByCode(

+5 -8

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

···

       32
       32
        
       }

     

       33
       33
        
       export const defaultFilter = ~(~0 << 7);

     

       34
       34
        
       

     

       35
       35
       -
       const channelModule =

     

       36
       36
       -
         spacepack.require.m[

     

       37
       37
       -
           spacepack.findByCode(

     

       38
       38
       -
             '"Missing channel in Channel.openChannelContextMenu"'

     

       39
       39
       -
           )[0].id

     

       40
       40
       -
         ].toString();

     

       41
       41
       -
       const moduleId = channelModule.match(/webpackId:"(.+?)"/)![1];

     

       42
       42
       -
       const modPromise = spacepack.require.el(moduleId);

     

       35
       35
       +
       const modPromise = spacepack.lazyLoad(

     

       36
       36
       +
         '"Missing channel in Channel.openChannelContextMenu"',

     

       37
       37
       +
         /e\("(\d+)"\)/g,

     

       38
       38
       +
         /webpackId:"(.+?)"/

     

       39
       39
       +
       );

     

       43
       40
        
       

     

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

     

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

+1 -1

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

···

       33
       33
        
           "is not a valid locale",

     

       34
       34
        
           /(.)\.error\(""\.concat\((.)," is not a valid locale\."\)\)/g

     

       35
       35
        
         ],

     

       36
       36
       -
         ['.displayName="RunningGameStore"', /.\.info\("games",{.+?}\),/],

     

       36
       36
       +
         ['="RunningGameStore"', /.\.info\("games",{.+?}\),/],

     

       37
       37
        
         [

     

       38
       38
        
           '"[BUILD INFO] Release Channel: "',

     

       39
       39
        
           /new .{1,2}\.default\(\)\.log\("\[BUILD INFO\] Release Channel: ".+?"\)\),/

+3 -3

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

···

       5
       5
        
         {

     

       6
       6
        
           find: ".UserSettingsSections.HOTSPOT_OPTIONS",

     

       7
       7
        
           replace: {

     

       8
       8
       -
             match: /\.CUSTOM,element:(.+?)}\];return (.{1,2})/,

     

       9
       9
       -
             replacement: (_, lastElement, sections) =>

     

       10
       10
       -
               `.CUSTOM,element:${lastElement}}];return require("settings_settings").Settings._mutateSections(${sections})`

     

       8
       8
       +
             match: /return(\[.+?\.CUSTOM,element:.+?}\])}/,

     

       9
       9
       +
             replacement: (_, arr) =>

     

       10
       10
       +
               `return require("settings_settings").Settings._mutateSections(${arr})}`

     

       11
       11
        
           }

     

       12
       12
        
         },

     

       13
       13
        
         {

+19 -8

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

···

       162
       162
        
           );

     

       163
       163
        
         },

     

       164
       164
        
       

     

       165
       165
       -
         lazyLoad: (find: string | RegExp | (string | RegExp)[], match: RegExp) => {

     

       166
       166
       -
           const module = Array.isArray(find)

     

       165
       165
       +
         lazyLoad: (

     

       166
       166
       +
           find: string | RegExp | (string | RegExp)[],

     

       167
       167
       +
           chunk: RegExp,

     

       168
       168
       +
           module: RegExp

     

       169
       169
       +
         ) => {

     

       170
       170
       +
           if (!chunk.flags.includes("g"))

     

       171
       171
       +
             return Promise.reject("Chunk ID regex must be global");

     

       172
       172
       +
       

     

       173
       173
       +
           const mod = Array.isArray(find)

     

       167
       174
        
             ? spacepack.findByCode(...find)

     

       168
       175
        
             : spacepack.findByCode(find);

     

       169
       169
       -
           if (module.length < 1) return Promise.reject("Find failed");

     

       176
       176
       +
           if (mod.length < 1) return Promise.reject("Module find failed");

     

       170
       177
        
       

     

       171
       171
       -
           const findId = module[0].id;

     

       178
       178
       +
           const findId = mod[0].id;

     

       172
       179
        
           const findCode = webpackRequire.m[findId].toString().replace(/\n/g, "");

     

       173
       180
        
       

     

       174
       174
       -
           const matchResult = findCode.match(match);

     

       175
       175
       -
           if (!matchResult) return Promise.reject("Match failed");

     

       181
       181
       +
           const chunkIds = [...findCode.matchAll(chunk)].map(([, id]) => id);

     

       182
       182
       +
           if (chunkIds.length === 0) return Promise.reject("Chunk ID match failed");

     

       183
       183
       +
       

     

       184
       184
       +
           const moduleId = findCode.match(module)?.[1];

     

       185
       185
       +
           if (!moduleId) return Promise.reject("Module ID match failed");

     

       176
       186
        
       

     

       177
       177
       -
           const matchId = matchResult[1];

     

       178
       178
       -
           return webpackRequire.el(matchId).then(() => webpackRequire(matchId));

     

       187
       187
       +
           return Promise.all(chunkIds.map((c) => webpackRequire.e(c))).then(() =>

     

       188
       188
       +
             webpackRequire(moduleId)

     

       189
       189
       +
           );

     

       179
       190
        
         },

     

       180
       191
        
       

     

       181
       192
        
         filterReal: (modules: WebpackModule[]) => {

+2 -1

packages/types/src/coreExtensions.ts

···

       29
       29
        
         ) => Function | null;

     

       30
       30
        
         lazyLoad: (

     

       31
       31
        
           find: string | RegExp | (string | RegExp)[],

     

       32
       32
       -
           match: RegExp

     

       32
       32
       +
           chunk: RegExp,

     

       33
       33
       +
           module: RegExp

     

       33
       34
        
         ) => Promise<any>;

     

       34
       35
        
         filterReal: (modules: WebpackModule[]) => WebpackModule[];

     

       35
       36
        
       };

+1 -1

packages/types/src/discord/webpack.ts

···

       3
       3
        
       export type WebpackRequireType = typeof WebpackRequire & {

     

       4
       4
        
         c: Record<string, WebpackModule>;

     

       5
       5
        
         m: Record<string, WebpackModuleFunc>;

     

       6
       6
       -
         el: (module: number | string) => Promise<void>;

     

       6
       6
       +
         e: (module: number | string) => Promise<void>;

     

       7
       7
        
       };

     

       8
       8
        
       

     

       9
       9
        
       export type WebpackModule = {