commit 2fe30e4d7209f9453318ff814349a792232da1f9 · notnite.com/moonlight

+1 -1

.prettierrc

···

       1
       1
        
       {

     

       2
       2
       -
         "printWidth": 80,

     

       2
       2
       +
         "printWidth": 120,

     

       3
       3
        
         "trailingComma": "none",

     

       4
       4
        
         "tabWidth": 2,

     

       5
       5
        
         "singleQuote": false

+1 -1

package.json

···

       17
       17
        
           "browser": "node build.mjs --browser",

     

       18
       18
        
           "browser-mv2": "node build.mjs --browser --mv2",

     

       19
       19
        
           "lint": "eslint packages",

     

       20
       20
       -
           "lint:fix": "eslint packages",

     

       20
       20
       +
           "lint:fix": "eslint packages --fix",

     

       21
       21
        
           "lint:report": "eslint --output-file eslint_report.json --format json packages",

     

       22
       22
        
           "typecheck": "tsc --noEmit",

     

       23
       23
        
           "check": "pnpm run lint && pnpm run typecheck",

+1 -2

packages/browser/src/background.js

···

       79
       79
        
                 args: [urls],

     

       80
       80
        
                 func: async (urls) => {

     

       81
       81
        
                   const scripts = [...document.querySelectorAll("script")].filter(

     

       82
       82
       -
                     (script) =>

     

       83
       83
       -
                       script.src && urls.some((url) => url.includes(script.src))

     

       82
       82
       +
                     (script) => script.src && urls.some((url) => url.includes(script.src))

     

       84
       83
        
                   );

     

       85
       84
        
       

     

       86
       85
        
                   // backwards

+4 -12

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

···

       5
       5
        
           find: "Menu API only allows Items and groups of Items as children.",

     

       6
       6
        
           replace: [

     

       7
       7
        
             {

     

       8
       8
       -
               match:

     

       9
       9
       -
                 /(?<=let{navId[^}]+?}=(.),(.)=function .\(.\){.+(?=,.=function))/,

     

       8
       8
       +
               match: /(?<=let{navId[^}]+?}=(.),(.)=function .\(.\){.+(?=,.=function))/,

     

       10
       9
        
               replacement: (_, props, items) =>

     

       11
       10
        
                 `,__contextMenu=!${props}.__contextMenu_evilMenu&&require("contextMenu_contextMenu")._patchMenu(${props}, ${items})`

     

       12
       11
        
             }

     
···

       17
       16
        
           replace: [

     

       18
       17
        
             {

     

       19
       18
        
               match: /(?<=let\{[^}]+?\}=.;return ).\({[^}]+?}\)/,

     

       20
       20
       -
               replacement: (render) =>

     

       21
       21
       -
                 `require("contextMenu_contextMenu")._saveProps(this,${render})`

     

       19
       19
       +
               replacement: (render) => `require("contextMenu_contextMenu")._saveProps(this,${render})`

     

       22
       20
        
             }

     

       23
       21
        
           ]

     

       24
       22
        
         }

     
···

       26
       24
        
       

     

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

     

       28
       26
        
         contextMenu: {

     

       29
       29
       -
           dependencies: [

     

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

     

       31
       31
       -
             "Menu API only allows Items and groups of Items as children."

     

       32
       32
       -
           ]

     

       27
       27
       +
           dependencies: [{ ext: "spacepack", id: "spacepack" }, "Menu API only allows Items and groups of Items as children."]

     

       33
       28
        
         },

     

       34
       29
        
         evilMenu: {

     

       35
       35
       -
           dependencies: [

     

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

     

       37
       37
       -
             "Menu API only allows Items and groups of Items as children."

     

       38
       38
       -
           ]

     

       30
       30
       +
           dependencies: [{ ext: "spacepack", id: "spacepack" }, "Menu API only allows Items and groups of Items as children."]

     

       39
       31
        
         }

     

       40
       32
        
       };

+4 -18

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

···

       1
       1
       -
       import {

     

       2
       2
       -
         InternalItem,

     

       3
       3
       -
         MenuElement,

     

       4
       4
       -
         MenuProps

     

       5
       5
       -
       } from "@moonlight-mod/types/coreExtensions/contextMenu";

     

       1
       1
       +
       import { InternalItem, MenuElement, MenuProps } from "@moonlight-mod/types/coreExtensions/contextMenu";

     

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

     

       7
       3
        
       import parser from "@moonlight-mod/wp/contextMenu_evilMenu";

     

       8
       4
        
       

     

       9
       5
        
       type Patch = {

     

       10
       6
        
         navId: string;

     

       11
       11
       -
         item: (

     

       12
       12
       -
           props: any

     

       13
       13
       -
         ) =>

     

       14
       14
       -
           | React.ReactComponentElement<MenuElement>

     

       15
       15
       -
           | React.ReactComponentElement<MenuElement>[];

     

       7
       7
       +
         item: (props: any) => React.ReactComponentElement<MenuElement> | React.ReactComponentElement<MenuElement>[];

     

       16
       8
        
         anchorId: string;

     

       17
       9
        
         before: boolean;

     

       18
       10
        
       };

     

       19
       11
        
       

     

       20
       12
        
       function addItem<T>(

     

       21
       13
        
         navId: string,

     

       22
       22
       -
         item: (

     

       23
       23
       -
           props: T

     

       24
       24
       -
         ) =>

     

       25
       25
       -
           | React.ReactComponentElement<MenuElement>

     

       26
       26
       -
           | React.ReactComponentElement<MenuElement>[],

     

       14
       14
       +
         item: (props: T) => React.ReactComponentElement<MenuElement> | React.ReactComponentElement<MenuElement>[],

     

       27
       15
        
         anchorId: string,

     

       28
       16
        
         before = false

     

       29
       17
        
       ) {

     
···

       65
       53
        
       // Unmangle Menu elements

     

       66
       54
        
       const code =

     

       67
       55
        
         spacepack.require.m[

     

       68
       68
       -
           spacepack.findByCode(

     

       69
       69
       -
             "Menu API only allows Items and groups of Items as children."

     

       70
       70
       -
           )[0].id

     

       56
       56
       +
           spacepack.findByCode("Menu API only allows Items and groups of Items as children.")[0].id

     

       71
       57
        
         ].toString();

     

       72
       58
        
       

     

       73
       59
        
       let MangledMenu;

+3 -13

packages/core-extensions/src/contextMenu/webpackModules/evilMenu.ts

···

       2
       2
        
       

     

       3
       3
        
       let code =

     

       4
       4
        
         spacepack.require.m[

     

       5
       5
       -
           spacepack.findByCode(

     

       6
       6
       -
             "Menu API only allows Items and groups of Items as children."

     

       7
       7
       -
           )[0].id

     

       5
       5
       +
           spacepack.findByCode("Menu API only allows Items and groups of Items as children.")[0].id

     

       8
       6
        
         ].toString();

     

       9
       7
        
       code = code.replace(/,.=(?=function .\(.\){.+?,.=function)/, ";return ");

     

       10
       8
        
       code = code.replace(/,(?=__contextMenu)/, ";let ");

     

       11
       11
       -
       const mod = new Function(

     

       12
       12
       -
         "module",

     

       13
       13
       -
         "exports",

     

       14
       14
       -
         "require",

     

       15
       15
       -
         `(${code}).apply(this, arguments)`

     

       16
       16
       -
       );

     

       9
       9
       +
       const mod = new Function("module", "exports", "require", `(${code}).apply(this, arguments)`);

     

       17
       10
        
       const exp: any = {};

     

       18
       11
        
       mod({}, exp, require);

     

       19
       19
       -
       const Menu = spacepack.findFunctionByStrings(

     

       20
       20
       -
         exp,

     

       21
       21
       -
         "Menu API only allows Items and groups of Items as children."

     

       22
       22
       -
       )!;

     

       12
       12
       +
       const Menu = spacepack.findFunctionByStrings(exp, "Menu API only allows Items and groups of Items as children.")!;

     

       23
       13
        
       module.exports = (el: any) => {

     

       24
       14
        
         return Menu({

     

       25
       15
        
           children: el,

+1 -3

packages/core-extensions/src/devToolsExtensions/host.ts

···

       5
       5
        
       const logger = new Logger("DevTools Extensions");

     

       6
       6
        
       

     

       7
       7
        
       app.whenReady().then(async () => {

     

       8
       8
       -
         const paths =

     

       9
       9
       -
           moonlightHost.getConfigOption<string[]>("devToolsExtensions", "paths") ??

     

       10
       10
       -
           [];

     

       8
       8
       +
         const paths = moonlightHost.getConfigOption<string[]>("devToolsExtensions", "paths") ?? [];

     

       11
       9
        
       

     

       12
       10
        
         for (const path of paths) {

     

       13
       11
        
           const resolved = resolve(path);

+2 -7

packages/core-extensions/src/disableSentry/host.ts

···

       5
       5
        
       

     

       6
       6
        
       if (moonlightHost.asarPath !== "moonlightDesktop") {

     

       7
       7
        
         try {

     

       8
       8
       -
           const hostSentryPath = require.resolve(

     

       9
       9
       -
             join(moonlightHost.asarPath, "node_modules", "@sentry", "electron")

     

       10
       10
       -
           );

     

       11
       11
       -
           require.cache[hostSentryPath] = new Module(

     

       12
       12
       -
             hostSentryPath,

     

       13
       13
       -
             require.cache[require.resolve(moonlightHost.asarPath)]

     

       14
       14
       -
           );

     

       8
       8
       +
           const hostSentryPath = require.resolve(join(moonlightHost.asarPath, "node_modules", "@sentry", "electron"));

     

       9
       9
       +
           require.cache[hostSentryPath] = new Module(hostSentryPath, require.cache[require.resolve(moonlightHost.asarPath)]);

     

       15
       10
        
           require.cache[hostSentryPath]!.exports = {

     

       16
       11
        
             init: () => {},

     

       17
       12
        
             captureException: () => {},

+2 -7

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

···

       8
       8
        
       if (!ipcRenderer.sendSync(constants.ipcGetIsMoonlightDesktop)) {

     

       9
       9
        
         const preloadPath = ipcRenderer.sendSync(constants.ipcGetOldPreloadPath);

     

       10
       10
        
         try {

     

       11
       11
       -
           const sentryPath = require.resolve(

     

       12
       12
       -
             resolve(preloadPath, "..", "node_modules", "@sentry", "electron")

     

       13
       13
       -
           );

     

       14
       14
       -
           require.cache[sentryPath] = new Module(

     

       15
       15
       -
             sentryPath,

     

       16
       16
       -
             require.cache[require.resolve(preloadPath)]

     

       17
       17
       -
           );

     

       11
       11
       +
           const sentryPath = require.resolve(resolve(preloadPath, "..", "node_modules", "@sentry", "electron"));

     

       12
       12
       +
           require.cache[sentryPath] = new Module(sentryPath, require.cache[require.resolve(preloadPath)]);

     

       18
       13
        
           require.cache[sentryPath]!.exports = {

     

       19
       14
        
             init: () => {},

     

       20
       15
        
             setTag: () => {},

+1 -2

packages/core-extensions/src/disableSentry/webpackModules/stub.ts

···

       23
       23
        
                   throw Error("crash");

     

       24
       24
        
                 };

     

       25
       25
        
               } else if (keys.includes(prop.toString())) {

     

       26
       26
       -
                 return (...args: any[]) =>

     

       27
       27
       -
                   logger.debug(`Sentry calling "${prop.toString()}":`, ...args);

     

       26
       26
       +
                 return (...args: any[]) => logger.debug(`Sentry calling "${prop.toString()}":`, ...args);

     

       28
       27
        
               } else {

     

       29
       28
        
                 return undefined;

     

       30
       29
        
               }

+5 -17

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

···

       6
       6
        
           replace: [

     

       7
       7
        
             {

     

       8
       8
        
               match: /={newline:(.+?)},(.{1,2})=\(0,/,

     

       9
       9
       -
               replacement: (_, rules, RULES) =>

     

       10
       10
       -
                 `=require("markdown_markdown")._addRules({newline:${rules}}),${RULES}=(0,`

     

       9
       9
       +
               replacement: (_, rules, RULES) => `=require("markdown_markdown")._addRules({newline:${rules}}),${RULES}=(0,`

     

       11
       10
        
             },

     

       12
       11
        
             {

     

       13
       12
        
               match: /(?<=;(.{1,2}\.Z)={RULES:.+?})/,

     

       14
       14
       -
               replacement: (_, rulesets) =>

     

       15
       15
       -
                 `;require("markdown_markdown")._applyRulesetBlacklist(${rulesets});`

     

       13
       13
       +
               replacement: (_, rulesets) => `;require("markdown_markdown")._applyRulesetBlacklist(${rulesets});`

     

       16
       14
        
             }

     

       17
       15
        
           ]

     

       18
       16
        
         },

     
···

       25
       23
        
                 `__slateRules,${rulesDef}=__slateRules=require("markdown_markdown")._addSlateRules({link:{${rules}}),${syntaxBefore}=new Set`

     

       26
       24
        
             },

     

       27
       25
        
             {

     

       28
       28
       -
               match:

     

       29
       29
       -
                 /(originalMatch:.}=(.);)(.+?)case"emoticon":(return .+?;)(.+?)case"subtext":{(.+?)}default:/,

     

       30
       30
       -
               replacement: (

     

       31
       31
       -
                 _,

     

       32
       32
       -
                 start,

     

       33
       33
       -
                 rule,

     

       34
       34
       -
                 body,

     

       35
       35
       -
                 plaintextReturn,

     

       36
       36
       -
                 otherRules,

     

       37
       37
       -
                 inlineStyleBody

     

       38
       38
       -
               ) =>

     

       26
       26
       +
               match: /(originalMatch:.}=(.);)(.+?)case"emoticon":(return .+?;)(.+?)case"subtext":{(.+?)}default:/,

     

       27
       27
       +
               replacement: (_, start, rule, body, plaintextReturn, otherRules, inlineStyleBody) =>

     

       39
       28
        
                 `${start}if(${rule}.type.startsWith("__moonlight_")){if(__slateRules[${rule}.type].type=="inlineStyle"){${inlineStyleBody}}else{${plaintextReturn}}}${body}case"emoticon":${plaintextReturn}${otherRules}case"link":{${inlineStyleBody}}default:`

     

       40
       29
        
             }

     

       41
       30
        
           ]

     
···

       44
       33
        
           find: '"Slate: Unknown decoration attribute: "',

     

       45
       34
        
           replace: {

     

       46
       35
        
             match: /=({strong:.+?});/,

     

       47
       47
       -
             replacement: (_, rules) =>

     

       48
       48
       -
               `=require("markdown_markdown")._addSlateDecorators(${rules});`

     

       36
       36
       +
             replacement: (_, rules) => `=require("markdown_markdown")._addSlateDecorators(${rules});`

     

       49
       37
        
           }

     

       50
       38
        
         }

     

       51
       39
        
       ];

+4 -16

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

···

       1
       1
       -
       import {

     

       2
       2
       -
         MarkdownRule,

     

       3
       3
       -
         Ruleset,

     

       4
       4
       -
         SlateRule

     

       5
       5
       -
       } from "@moonlight-mod/types/coreExtensions/markdown";

     

       1
       1
       +
       import { MarkdownRule, Ruleset, SlateRule } from "@moonlight-mod/types/coreExtensions/markdown";

     

       6
       2
        
       

     

       7
       7
       -
       export const rules: Record<

     

       8
       8
       -
         string,

     

       9
       9
       -
         (rules: Record<string, MarkdownRule>) => MarkdownRule

     

       10
       10
       -
       > = {};

     

       11
       11
       -
       export const slateRules: Record<

     

       12
       12
       -
         string,

     

       13
       13
       -
         (rules: Record<string, SlateRule>) => SlateRule

     

       14
       14
       -
       > = {};

     

       3
       3
       +
       export const rules: Record<string, (rules: Record<string, MarkdownRule>) => MarkdownRule> = {};

     

       4
       4
       +
       export const slateRules: Record<string, (rules: Record<string, SlateRule>) => SlateRule> = {};

     

       15
       5
        
       export const slateDecorators: Record<string, string> = {};

     

       16
       6
        
       export const ruleBlacklists: Record<Ruleset, Record<string, boolean>> = {

     

       17
       7
        
         RULES: {},

     
···

       66
       56
        
         return originalRules;

     

       67
       57
        
       }

     

       68
       58
        
       

     

       69
       69
       -
       export function _applyRulesetBlacklist(

     

       70
       70
       -
         rulesets: Record<Ruleset, Record<string, MarkdownRule>>

     

       71
       71
       -
       ) {

     

       59
       59
       +
       export function _applyRulesetBlacklist(rulesets: Record<Ruleset, Record<string, MarkdownRule>>) {

     

       72
       60
        
         for (const ruleset of Object.keys(rulesets) as Ruleset[]) {

     

       73
       61
        
           if (ruleset === "RULES") continue;

     

       74
       62

+1 -4

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

···

       2
       2
        
       

     

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

     

       4
       4
        
         stores: {

     

       5
       5
       -
           dependencies: [

     

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

     

       7
       7
       -
             { id: "discord/Dispatcher" }

     

       8
       8
       -
           ]

     

       5
       5
       +
           dependencies: [{ id: "discord/packages/flux" }, { id: "discord/Dispatcher" }]

     

       9
       6
        
         },

     

       10
       7
        
       

     

       11
       8
        
         ui: {

+5 -17

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

···

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

     

       2
       2
        
       import type { MoonbaseNatives, RepositoryManifest } from "./types";

     

       3
       3
        
       import extractAsar from "@moonlight-mod/core/asar";

     

       4
       4
       -
       import {

     

       5
       5
       -
         distDir,

     

       6
       6
       -
         repoUrlFile,

     

       7
       7
       -
         installedVersionFile

     

       8
       8
       -
       } from "@moonlight-mod/types/constants";

     

       4
       4
       +
       import { distDir, repoUrlFile, installedVersionFile } from "@moonlight-mod/types/constants";

     

       9
       5
        
       import { parseTarGzip } from "nanotar";

     

       10
       6
        
       

     

       11
       7
        
       const githubRepo = "moonlight-mod/moonlight";

     
···

       121
       117
        
       

     

       122
       118
        
               const fullFile = moonlightFS.join(dist, file.name);

     

       123
       119
        
               const fullDir = moonlightFS.dirname(fullFile);

     

       124
       124
       -
               if (!(await moonlightFS.exists(fullDir)))

     

       125
       125
       -
                 await moonlightFS.mkdir(fullDir);

     

       120
       120
       +
               if (!(await moonlightFS.exists(fullDir))) await moonlightFS.mkdir(fullDir);

     

       126
       121
        
               await moonlightFS.writeFile(fullFile, file.data);

     

       127
       122
        
             }

     

       128
       123
        
       

     

       129
       124
        
             logger.debug("Writing version file:", ref);

     

       130
       130
       -
             const versionFile = moonlightFS.join(

     

       131
       131
       -
               moonlightNode.getMoonlightDir(),

     

       132
       132
       -
               installedVersionFile

     

       133
       133
       -
             );

     

       125
       125
       +
             const versionFile = moonlightFS.join(moonlightNode.getMoonlightDir(), installedVersionFile);

     

       134
       126
        
             await moonlightFS.writeFileString(versionFile, ref.trim());

     

       135
       127
        
       

     

       136
       128
        
             logger.debug("Update extracted");

     
···

       176
       168
        
               const fullFile = moonlightFS.join(dir, file);

     

       177
       169
        
               const fullDir = moonlightFS.dirname(fullFile);

     

       178
       170
        
       

     

       179
       179
       -
               if (!(await moonlightFS.exists(fullDir)))

     

       180
       180
       -
                 await moonlightFS.mkdir(fullDir);

     

       171
       171
       +
               if (!(await moonlightFS.exists(fullDir))) await moonlightFS.mkdir(fullDir);

     

       181
       172
        
               await moonlightFS.writeFile(moonlightFS.join(dir, file), buf);

     

       182
       173
        
             }

     

       183
       174
        
       

     

       184
       184
       -
             await moonlightFS.writeFileString(

     

       185
       185
       -
               moonlightFS.join(dir, repoUrlFile),

     

       186
       186
       -
               repo

     

       187
       187
       -
             );

     

       175
       175
       +
             await moonlightFS.writeFileString(moonlightFS.join(dir, repoUrlFile), repo);

     

       188
       176
        
           },

     

       189
       177
        
       

     

       190
       178
        
           async deleteExtension(id) {

+2 -8

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

···

       5
       5
        
         checkForMoonlightUpdate(): Promise<string | null>;

     

       6
       6
        
         updateMoonlight(): Promise<void>;

     

       7
       7
        
       

     

       8
       8
       -
         fetchRepositories(

     

       9
       9
       -
           repos: string[]

     

       10
       10
       -
         ): Promise<Record<string, RepositoryManifest[]>>;

     

       11
       11
       -
         installExtension(

     

       12
       12
       -
           manifest: RepositoryManifest,

     

       13
       13
       -
           url: string,

     

       14
       14
       -
           repo: string

     

       15
       15
       -
         ): Promise<void>;

     

       8
       8
       +
         fetchRepositories(repos: string[]): Promise<Record<string, RepositoryManifest[]>>;

     

       9
       9
       +
         installExtension(manifest: RepositoryManifest, url: string, repo: string): Promise<void>;

     

       16
       10
        
         deleteExtension(id: string): Promise<void>;

     

       17
       11
        
         getExtensionConfig(id: string, key: string): any;

     

       18
       12
        
       };

+6 -29

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

···

       12
       12
        
       

     

       13
       13
        
       const Margins = spacepack.require("discord/styles/shared/Margins.css");

     

       14
       14
        
       

     

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

     

       16
       16
       -
         .exports.Z;

     

       15
       15
       +
       const { open } = spacepack.findByExports("setSection", "clearSubsection")[0].exports.Z;

     

       17
       16
        
       

     

       18
       17
        
       const notice = {

     

       19
       18
        
         stores: [MoonbaseSettingsStore],

     

       20
       19
        
         element: () => {

     

       21
       20
        
           // Require it here because lazy loading SUX

     

       22
       22
       -
           const SettingsNotice = spacepack.findByCode(

     

       23
       23
       -
             "onSaveButtonColor",

     

       24
       24
       -
             "FocusRingScope"

     

       25
       25
       -
           )[0].exports.Z;

     

       21
       21
       +
           const SettingsNotice = spacepack.findByCode("onSaveButtonColor", "FocusRingScope")[0].exports.Z;

     

       26
       22
        
           return (

     

       27
       23
        
             <SettingsNotice

     

       28
       24
        
               submitting={MoonbaseSettingsStore.submitting}

     
···

       37
       33
        
         }

     

       38
       34
        
       };

     

       39
       35
        
       

     

       40
       40
       -
       function addSection(

     

       41
       41
       -
         id: string,

     

       42
       42
       -
         name: string,

     

       43
       43
       -
         element: React.FunctionComponent

     

       44
       44
       -
       ) {

     

       36
       36
       +
       function addSection(id: string, name: string, element: React.FunctionComponent) {

     

       45
       37
        
         settings.addSection(`moonbase-${id}`, name, element, null, -2, notice);

     

       46
       38
        
       }

     

       47
       39
        
       

     
···

       53
       45
        
       

     

       54
       46
        
       function renderBreadcrumb(crumb: Breadcrumb, last: boolean) {

     

       55
       47
        
         return (

     

       56
       56
       -
           <Text

     

       57
       57
       -
             variant="heading-lg/semibold"

     

       58
       58
       -
             tag="h2"

     

       59
       59
       -
             color={last ? "header-primary" : "header-secondary"}

     

       60
       60
       -
           >

     

       48
       48
       +
           <Text variant="heading-lg/semibold" tag="h2" color={last ? "header-primary" : "header-secondary"}>

     

       61
       49
        
             {crumb.label}

     

       62
       50
        
           </Text>

     

       63
       51
        
         );

     

       64
       52
        
       }

     

       65
       53
        
       

     

       66
       66
       -
       if (

     

       67
       67
       -
         MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       68
       68
       -
           "moonbase",

     

       69
       69
       -
           "sections",

     

       70
       70
       -
           false

     

       71
       71
       -
         )

     

       72
       72
       -
       ) {

     

       54
       54
       +
       if (MoonbaseSettingsStore.getExtensionConfigRaw<boolean>("moonbase", "sections", false)) {

     

       73
       55
        
         settings.addHeader("Moonbase", -2);

     

       74
       56
        
       

     

       75
       57
        
         for (const page of pages) {

     
···

       102
       84
        
         settings.addSectionMenuItems(

     

       103
       85
        
           "moonbase",

     

       104
       86
        
           ...pages.map((page, i) => (

     

       105
       105
       -
             <MenuItem

     

       106
       106
       -
               key={page.id}

     

       107
       107
       -
               id={`moonbase-${page.id}`}

     

       108
       108
       -
               label={page.name}

     

       109
       109
       -
               action={() => open("moonbase", i)}

     

       110
       110
       -
             />

     

       87
       87
       +
             <MenuItem key={page.id} id={`moonbase-${page.id}`} label={page.name} action={() => open("moonbase", i)} />

     

       111
       88
        
           ))

     

       112
       89
        
         );

     

       113
       90
        
       }

+16 -55

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

···

       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";

     

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

     

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

     

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

     

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

     

       11
       6
        
       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
       7
       +
       import { checkExtensionCompat, ExtensionCompat } from "@moonlight-mod/core/extension/loader";

     

       16
       8
        
       import { CustomComponent } from "@moonlight-mod/types/coreExtensions/moonbase";

     

       17
       9
        
       

     

       18
       10
        
       const logger = moonlight.getLogger("moonbase");

     
···

       24
       16
        
         private origConfig: Config;

     

       25
       17
        
         private config: Config;

     

       26
       18
        
         private extensionIndex: number;

     

       27
       27
       -
         private configComponents: Record<string, Record<string, CustomComponent>> =

     

       28
       28
       -
           {};

     

       19
       19
       +
         private configComponents: Record<string, Record<string, CustomComponent>> = {};

     

       29
       20
        
       

     

       30
       21
        
         modified: boolean;

     

       31
       22
        
         submitting: boolean;

     
···

       64
       55
        
             this.extensions[uniqueId] = {

     

       65
       56
        
               ...ext,

     

       66
       57
        
               uniqueId,

     

       67
       67
       -
               state: moonlight.enabledExtensions.has(ext.id)

     

       68
       68
       -
                 ? ExtensionState.Enabled

     

       69
       69
       -
                 : ExtensionState.Disabled,

     

       58
       58
       +
               state: moonlight.enabledExtensions.has(ext.id) ? ExtensionState.Enabled : ExtensionState.Disabled,

     

       70
       59
        
               compat: checkExtensionCompat(ext.manifest),

     

       71
       60
        
               hasUpdate: false

     

       72
       61
        
             };

     
···

       90
       79
        
                     };

     

       91
       80
        
       

     

       92
       81
        
                     // Don't present incompatible updates

     

       93
       93
       -
                     if (checkExtensionCompat(ext) !== ExtensionCompat.Compatible)

     

       94
       94
       -
                       continue;

     

       82
       82
       +
                     if (checkExtensionCompat(ext) !== ExtensionCompat.Compatible) continue;

     

       95
       83
        
       

     

       96
       84
        
                     const existing = this.getExisting(extensionData);

     

       97
       85
        
                     if (existing != null) {

     
···

       137
       125
        
               this.emitChange();

     

       138
       126
        
             })

     

       139
       127
        
             .then(() => {

     

       140
       140
       -
               this.shouldShowNotice =

     

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

     

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

     

       142
       129
        
               this.emitChange();

     

       143
       130
        
             });

     

       144
       131
        
         }

     

       145
       132
        
       

     

       146
       133
        
         private getExisting(ext: MoonbaseExtension) {

     

       147
       147
       -
           return Object.values(this.extensions).find(

     

       148
       148
       -
             (e) => e.id === ext.id && e.source.url === ext.source.url

     

       149
       149
       -
           );

     

       134
       134
       +
           return Object.values(this.extensions).find((e) => e.id === ext.id && e.source.url === ext.source.url);

     

       150
       135
        
         }

     

       151
       136
        
       

     

       152
       137
        
         private hasUpdate(ext: MoonbaseExtension) {

     

       153
       153
       -
           const existing = Object.values(this.extensions).find(

     

       154
       154
       -
             (e) => e.id === ext.id && e.source.url === ext.source.url

     

       155
       155
       -
           );

     

       138
       138
       +
           const existing = Object.values(this.extensions).find((e) => e.id === ext.id && e.source.url === ext.source.url);

     

       156
       139
        
           if (existing == null) return false;

     

       157
       140
        
       

     

       158
       158
       -
           return (

     

       159
       159
       -
             existing.manifest.version !== ext.manifest.version &&

     

       160
       160
       -
             existing.state !== ExtensionState.NotDownloaded

     

       161
       161
       -
           );

     

       141
       141
       +
           return existing.manifest.version !== ext.manifest.version && existing.state !== ExtensionState.NotDownloaded;

     

       162
       142
        
         }

     

       163
       143
        
       

     

       164
       144
        
         // Jank

     
···

       181
       161
        
         }

     

       182
       162
        
       

     

       183
       163
        
         getExtensionUniqueId(id: string) {

     

       184
       184
       -
           return Object.values(this.extensions).find((ext) => ext.id === id)

     

       185
       185
       -
             ?.uniqueId;

     

       164
       164
       +
           return Object.values(this.extensions).find((ext) => ext.id === id)?.uniqueId;

     

       186
       165
        
         }

     

       187
       166
        
       

     

       188
       167
        
         getExtensionConflicting(uniqueId: number) {

     

       189
       168
        
           const ext = this.getExtension(uniqueId);

     

       190
       169
        
           if (ext.state !== ExtensionState.NotDownloaded) return false;

     

       191
       170
        
           return Object.values(this.extensions).some(

     

       192
       192
       -
             (e) =>

     

       193
       193
       -
               e.id === ext.id &&

     

       194
       194
       -
               e.uniqueId !== uniqueId &&

     

       195
       195
       -
               e.state !== ExtensionState.NotDownloaded

     

       171
       171
       +
             (e) => e.id === ext.id && e.uniqueId !== uniqueId && e.state !== ExtensionState.NotDownloaded

     

       196
       172
        
           );

     

       197
       173
        
         }

     

       198
       174
        
       

     
···

       223
       199
        
           return cfg.config?.[key] ?? clonedDefaultValue;

     

       224
       200
        
         }

     

       225
       201
        
       

     

       226
       226
       -
         getExtensionConfigRaw<T>(

     

       227
       227
       -
           id: string,

     

       228
       228
       -
           key: string,

     

       229
       229
       -
           defaultValue: T | undefined

     

       230
       230
       -
         ): T | undefined {

     

       202
       202
       +
         getExtensionConfigRaw<T>(id: string, key: string, defaultValue: T | undefined): T | undefined {

     

       231
       203
        
           const cfg = this.config.extensions[id];

     

       232
       204
        
       

     

       233
       205
        
           if (cfg == null || typeof cfg === "boolean") return defaultValue;

     
···

       299
       271
        
               this.extensions[uniqueId].state = ExtensionState.Disabled;

     

       300
       272
        
             }

     

       301
       273
        
       

     

       302
       302
       -
             if (update != null)

     

       303
       303
       -
               this.extensions[uniqueId].compat = checkExtensionCompat(

     

       304
       304
       -
                 update.updateManifest

     

       305
       305
       -
               );

     

       274
       274
       +
             if (update != null) this.extensions[uniqueId].compat = checkExtensionCompat(update.updateManifest);

     

       306
       275
        
       

     

       307
       276
        
             delete this.updates[uniqueId];

     

       308
       277
        
           } catch (e) {

     
···

       335
       304
        
       

     

       336
       305
        
           const deps: Record<string, MoonbaseExtension[]> = {};

     

       337
       306
        
           for (const dep of missingDeps) {

     

       338
       338
       -
             const candidates = Object.values(this.extensions).filter(

     

       339
       339
       -
               (e) => e.id === dep

     

       340
       340
       -
             );

     

       307
       307
       +
             const candidates = Object.values(this.extensions).filter((e) => e.id === dep);

     

       341
       308
        
       

     

       342
       309
        
             deps[dep] = candidates.sort((a, b) => {

     

       343
       310
        
               const aRank = this.getRank(a);

     

       344
       311
        
               const bRank = this.getRank(b);

     

       345
       312
        
               if (aRank === bRank) {

     

       346
       313
        
                 const repoIndex = this.config.repositories.indexOf(a.source.url!);

     

       347
       347
       -
                 const otherRepoIndex = this.config.repositories.indexOf(

     

       348
       348
       -
                   b.source.url!

     

       349
       349
       -
                 );

     

       314
       314
       +
                 const otherRepoIndex = this.config.repositories.indexOf(b.source.url!);

     

       350
       315
        
                 return repoIndex - otherRepoIndex;

     

       351
       316
        
               } else {

     

       352
       317
        
                 return bRank - aRank;

     
···

       392
       357
        
           return (uniqueId != null ? this.getExtensionName(uniqueId) : null) ?? id;

     

       393
       358
        
         }

     

       394
       359
        
       

     

       395
       395
       -
         registerConfigComponent(

     

       396
       396
       -
           ext: string,

     

       397
       397
       -
           name: string,

     

       398
       398
       -
           component: CustomComponent

     

       399
       399
       -
         ) {

     

       360
       360
       +
         registerConfigComponent(ext: string, name: string, component: CustomComponent) {

     

       400
       361
        
           if (!(ext in this.configComponents)) this.configComponents[ext] = {};

     

       401
       362
        
           this.configComponents[ext][name] = component;

     

       402
       363
        
         }

+8 -34

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

···

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

     

       2
       2
        
       

     

       3
       3
       -
       const logLevels = Object.values(LogLevel).filter(

     

       4
       4
       -
         (v) => typeof v === "string"

     

       5
       5
       -
       ) as string[];

     

       3
       3
       +
       const logLevels = Object.values(LogLevel).filter((v) => typeof v === "string") as string[];

     

       6
       4
        
       

     

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

     

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

     
···

       32
       30
        
           /\[(?:.\.e\("\d+?"\),?)+\][^}]+?webpackId:\d+,name:"GuildSettings"/,

     

       33
       31
        
           /webpackId:(\d+),name:"GuildSettings"/

     

       34
       32
        
         )

     

       35
       35
       -
         .then(

     

       36
       36
       -
           () =>

     

       37
       37
       -
             (RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0]

     

       38
       38
       -
               .exports)

     

       39
       39
       -
         );

     

       33
       33
       +
         .then(() => (RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0].exports));

     

       40
       34
        
       

     

       41
       35
        
       // FIXME: type component keys

     

       42
       36
        
       const { CircleXIcon } = Components;

     
···

       46
       40
        
           <div className={RemoveButtonClasses.removeButtonContainer}>

     

       47
       41
        
             <Tooltip text="Remove entry" position="top">

     

       48
       42
        
               {(props: any) => (

     

       49
       49
       -
                 <Clickable

     

       50
       50
       -
                   {...props}

     

       51
       51
       -
                   className={RemoveButtonClasses.removeButton}

     

       52
       52
       -
                   onClick={onClick}

     

       53
       53
       -
                 >

     

       43
       43
       +
                 <Clickable {...props} className={RemoveButtonClasses.removeButton} onClick={onClick}>

     

       54
       44
        
                   <CircleXIcon width={24} height={24} />

     

       55
       45
        
                 </Clickable>

     

       56
       46
        
               )}

     
···

       59
       49
        
         );

     

       60
       50
        
       }

     

       61
       51
        
       

     

       62
       62
       -
       function ArrayFormItem({

     

       63
       63
       -
         config

     

       64
       64
       -
       }: {

     

       65
       65
       -
         config: "repositories" | "devSearchPaths";

     

       66
       66
       -
       }) {

     

       52
       52
       +
       function ArrayFormItem({ config }: { config: "repositories" | "devSearchPaths" }) {

     

       67
       53
        
         const items = MoonbaseSettingsStore.getConfigOption(config) ?? [];

     

       68
       54
        
         return (

     

       69
       55
        
           <Flex

     
···

       123
       109
        
           <>

     

       124
       110
        
             <FormSwitch

     

       125
       111
        
               className={Margins.marginTop20}

     

       126
       126
       -
               value={MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       127
       127
       -
                 "moonbase",

     

       128
       128
       -
                 "updateChecking",

     

       129
       129
       -
                 true

     

       130
       130
       -
               )}

     

       112
       112
       +
               value={MoonbaseSettingsStore.getExtensionConfigRaw<boolean>("moonbase", "updateChecking", true)}

     

       131
       113
        
               onChange={(value: boolean) => {

     

       132
       132
       -
                 MoonbaseSettingsStore.setExtensionConfig(

     

       133
       133
       -
                   "moonbase",

     

       134
       134
       -
                   "updateChecking",

     

       135
       135
       -
                   value

     

       136
       136
       -
                 );

     

       114
       114
       +
                 MoonbaseSettingsStore.setExtensionConfig("moonbase", "updateChecking", value);

     

       137
       115
        
               }}

     

       138
       116
        
               note="Checks for updates to moonlight"

     

       139
       117
        
             >

     

       140
       118
        
               Automatic update checking

     

       141
       119
        
             </FormSwitch>

     

       142
       120
        
             <FormItem title="Repositories">

     

       143
       143
       -
               <FormText className={Margins.marginBottom4}>

     

       144
       144
       -
                 A list of remote repositories to display extensions from

     

       145
       145
       -
               </FormText>

     

       121
       121
       +
               <FormText className={Margins.marginBottom4}>A list of remote repositories to display extensions from</FormText>

     

       146
       122
        
               <ArrayFormItem config="repositories" />

     

       147
       123
        
             </FormItem>

     

       148
       124
        
             <FormDivider className={FormClasses.dividerDefault} />

     
···

       172
       148
        
                   value: o.toLowerCase(),

     

       173
       149
        
                   label: o[0] + o.slice(1).toLowerCase()

     

       174
       150
        
                 }))}

     

       175
       175
       -
                 onChange={(v) =>

     

       176
       176
       -
                   MoonbaseSettingsStore.setConfigOption("loggerLevel", v)

     

       177
       177
       -
                 }

     

       151
       151
       +
                 onChange={(v) => MoonbaseSettingsStore.setConfigOption("loggerLevel", v)}

     

       178
       152
        
               />

     

       179
       153
        
             </FormItem>

     

       180
       154
        
           </>

+28 -84

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

···

       22
       22
        
       

     

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

     

       24
       24
        
       

     

       25
       25
       -
       const { BeakerIcon, DownloadIcon, TrashIcon, CircleWarningIcon, Tooltip } =

     

       26
       26
       -
         Components;

     

       25
       25
       +
       const { BeakerIcon, DownloadIcon, TrashIcon, CircleWarningIcon, Tooltip } = Components;

     

       27
       26
        
       

     

       28
       27
        
       const PanelButton = spacepack.findByCode("Masks.PANEL_BUTTON")[0].exports.Z;

     

       29
       29
       -
       const TabBarClasses = spacepack.findByExports(

     

       30
       30
       -
         "tabBar",

     

       31
       31
       -
         "tabBarItem",

     

       32
       32
       -
         "headerContentWrapper"

     

       33
       33
       -
       )[0].exports;

     

       34
       34
       -
       const MarkupClasses = spacepack.findByExports("markup", "inlineFormat")[0]

     

       35
       35
       -
         .exports;

     

       28
       28
       +
       const TabBarClasses = spacepack.findByExports("tabBar", "tabBarItem", "headerContentWrapper")[0].exports;

     

       29
       29
       +
       const MarkupClasses = spacepack.findByExports("markup", "inlineFormat")[0].exports;

     

       36
       30
        
       

     

       37
       37
       -
       const BuildOverrideClasses = spacepack.findByExports(

     

       38
       38
       -
         "disabledButtonOverride"

     

       39
       39
       -
       )[0].exports;

     

       31
       31
       +
       const BuildOverrideClasses = spacepack.findByExports("disabledButtonOverride")[0].exports;

     

       40
       32
        
       

     

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

     

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

     
···

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

     

       49
       41
        
         const [restartNeeded, setRestartNeeded] = React.useState(false);

     

       50
       42
        
       

     

       51
       51
       -
         const { ext, enabled, busy, update, conflicting } = useStateFromStores(

     

       52
       52
       -
           [MoonbaseSettingsStore],

     

       53
       53
       -
           () => {

     

       54
       54
       -
             return {

     

       55
       55
       -
               ext: MoonbaseSettingsStore.getExtension(uniqueId),

     

       56
       56
       -
               enabled: MoonbaseSettingsStore.getExtensionEnabled(uniqueId),

     

       57
       57
       -
               busy: MoonbaseSettingsStore.busy,

     

       58
       58
       -
               update: MoonbaseSettingsStore.getExtensionUpdate(uniqueId),

     

       59
       59
       -
               conflicting: MoonbaseSettingsStore.getExtensionConflicting(uniqueId)

     

       60
       60
       -
             };

     

       61
       61
       -
           }

     

       62
       62
       -
         );

     

       43
       43
       +
         const { ext, enabled, busy, update, conflicting } = useStateFromStores([MoonbaseSettingsStore], () => {

     

       44
       44
       +
           return {

     

       45
       45
       +
             ext: MoonbaseSettingsStore.getExtension(uniqueId),

     

       46
       46
       +
             enabled: MoonbaseSettingsStore.getExtensionEnabled(uniqueId),

     

       47
       47
       +
             busy: MoonbaseSettingsStore.busy,

     

       48
       48
       +
             update: MoonbaseSettingsStore.getExtensionUpdate(uniqueId),

     

       49
       49
       +
             conflicting: MoonbaseSettingsStore.getExtensionConflicting(uniqueId)

     

       50
       50
       +
           };

     

       51
       51
       +
         });

     

       63
       52
        
       

     

       64
       53
        
         // Why it work like that :sob:

     

       65
       54
        
         if (ext == null) return <></>;

     
···

       72
       61
        
         const enabledDependants = useStateFromStores([MoonbaseSettingsStore], () =>

     

       73
       62
        
           Object.keys(MoonbaseSettingsStore.extensions)

     

       74
       63
        
             .filter((uniqueId) => {

     

       75
       75
       -
               const potentialDependant = MoonbaseSettingsStore.getExtension(

     

       76
       76
       -
                 parseInt(uniqueId)

     

       77
       77
       -
               );

     

       64
       64
       +
               const potentialDependant = MoonbaseSettingsStore.getExtension(parseInt(uniqueId));

     

       78
       65
        
       

     

       79
       66
        
               return (

     

       80
       67
        
                 potentialDependant.manifest.dependencies?.includes(ext.id) &&

     
···

       90
       77
        
             <div className={IntegrationCard.cardHeader}>

     

       91
       78
        
               <Flex direction={Flex.Direction.VERTICAL}>

     

       92
       79
        
                 <Flex direction={Flex.Direction.HORIZONTAL} align={Flex.Align.CENTER}>

     

       93
       93
       -
                   <Text variant="text-md/semibold">

     

       94
       94
       -
                     {ext.manifest?.meta?.name ?? ext.id}

     

       95
       95
       -
                   </Text>

     

       80
       80
       +
                   <Text variant="text-md/semibold">{ext.manifest?.meta?.name ?? ext.id}</Text>

     

       96
       81
        
                   {ext.source.type === ExtensionLoadSource.Developer && (

     

       97
       82
        
                     <Tooltip text="This is a local extension" position="top">

     

       98
       98
       -
                       {(props: any) => (

     

       99
       99
       -
                         <BeakerIcon

     

       100
       100
       -
                           {...props}

     

       101
       101
       -
                           class={BuildOverrideClasses.infoIcon}

     

       102
       102
       -
                           size="xs"

     

       103
       103
       -
                         />

     

       104
       104
       -
                       )}

     

       83
       83
       +
                       {(props: any) => <BeakerIcon {...props} class={BuildOverrideClasses.infoIcon} size="xs" />}

     

       105
       84
        
                     </Tooltip>

     

       106
       85
        
                   )}

     

       107
       86
        
                 </Flex>

     

       108
       87
        
       

     

       109
       109
       -
                 {tagline != null && (

     

       110
       110
       -
                   <Text variant="text-sm/normal">{MarkupUtils.parse(tagline)}</Text>

     

       111
       111
       -
                 )}

     

       88
       88
       +
                 {tagline != null && <Text variant="text-sm/normal">{MarkupUtils.parse(tagline)}</Text>}

     

       112
       89
        
               </Flex>

     

       113
       90
        
       

     

       114
       114
       -
               <Flex

     

       115
       115
       -
                 direction={Flex.Direction.HORIZONTAL}

     

       116
       116
       -
                 align={Flex.Align.END}

     

       117
       117
       -
                 justify={Flex.Justify.END}

     

       118
       118
       -
               >

     

       91
       91
       +
               <Flex direction={Flex.Direction.HORIZONTAL} align={Flex.Align.END} justify={Flex.Justify.END}>

     

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

     

       120
       120
       -
                   <Tooltip

     

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

     

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

     

       123
       123
       -
                   >

     

       93
       93
       +
                   <Tooltip text={COMPAT_TEXT_MAP[ext.compat]} shouldShow={ext.compat !== ExtensionCompat.Compatible}>

     

       124
       94
        
                     {(props: any) => (

     

       125
       95
        
                       <Button

     

       126
       96
        
                         {...props}

     

       127
       97
        
                         color={Button.Colors.BRAND}

     

       128
       98
        
                         submitting={busy}

     

       129
       129
       -
                         disabled={

     

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

     

       131
       131
       -
                         }

     

       99
       99
       +
                         disabled={ext.compat !== ExtensionCompat.Compatible || conflicting}

     

       132
       100
        
                         onClick={async () => {

     

       133
       101
        
                           await installWithDependencyPopup(uniqueId);

     

       134
       102
        
                         }}

     
···

       168
       136
        
       

     

       169
       137
        
                     {restartNeeded && (

     

       170
       138
        
                       <PanelButton

     

       171
       171
       -
                         icon={() => (

     

       172
       172
       -
                           <CircleWarningIcon

     

       173
       173
       -
                             color={Components.tokens.colors.STATUS_DANGER}

     

       174
       174
       -
                           />

     

       175
       175
       -
                         )}

     

       139
       139
       +
                         icon={() => <CircleWarningIcon color={Components.tokens.colors.STATUS_DANGER} />}

     

       176
       140
        
                         onClick={() => window.location.reload()}

     

       177
       141
        
                         tooltipText="You will need to reload/restart your client for this extension to work properly."

     

       178
       142
        
                       />

     

       179
       143
        
                     )}

     

       180
       144
        
       

     

       181
       145
        
                     <FormSwitch

     

       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
       -
                       }

     

       146
       146
       +
                       value={ext.compat === ExtensionCompat.Compatible && (enabled || implicitlyEnabled)}

     

       147
       147
       +
                       disabled={implicitlyEnabled || ext.compat !== ExtensionCompat.Compatible}

     

       189
       148
        
                       hideBorder={true}

     

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

     

       191
       150
        
                       tooltipNote={

     
···

       194
       153
        
                           : implicitlyEnabled

     

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

     

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

     

       197
       197
       -
                               }: ${enabledDependants

     

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

     

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

     

       156
       156
       +
                               }: ${enabledDependants.map((a) => a.manifest.meta?.name ?? a.id).join(", ")}`

     

       200
       157
        
                             : undefined

     

       201
       158
        
                       }

     

       202
       159
        
                       onChange={() => {

     
···

       220
       177
        
                     padding: "0 20px"

     

       221
       178
        
                   }}

     

       222
       179
        
                 >

     

       223
       223
       -
                   <TabBar.Item

     

       224
       224
       -
                     className={TabBarClasses.tabBarItem}

     

       225
       225
       -
                     id={ExtensionPage.Info}

     

       226
       226
       -
                   >

     

       180
       180
       +
                   <TabBar.Item className={TabBarClasses.tabBarItem} id={ExtensionPage.Info}>

     

       227
       181
        
                     Info

     

       228
       182
        
                   </TabBar.Item>

     

       229
       183
        
       

     

       230
       184
        
                   {description != null && (

     

       231
       231
       -
                     <TabBar.Item

     

       232
       232
       -
                       className={TabBarClasses.tabBarItem}

     

       233
       233
       -
                       id={ExtensionPage.Description}

     

       234
       234
       -
                     >

     

       185
       185
       +
                     <TabBar.Item className={TabBarClasses.tabBarItem} id={ExtensionPage.Description}>

     

       235
       186
        
                       Description

     

       236
       187
        
                     </TabBar.Item>

     

       237
       188
        
                   )}

     

       238
       189
        
       

     

       239
       190
        
                   {settings != null && (

     

       240
       240
       -
                     <TabBar.Item

     

       241
       241
       -
                       className={TabBarClasses.tabBarItem}

     

       242
       242
       -
                       id={ExtensionPage.Settings}

     

       243
       243
       -
                     >

     

       191
       191
       +
                     <TabBar.Item className={TabBarClasses.tabBarItem} id={ExtensionPage.Settings}>

     

       244
       192
        
                       Settings

     

       245
       193
        
                     </TabBar.Item>

     

       246
       194
        
                   )}

     
···

       256
       204
        
               >

     

       257
       205
        
                 {tab === ExtensionPage.Info && <ExtensionInfo ext={ext} />}

     

       258
       206
        
                 {tab === ExtensionPage.Description && (

     

       259
       259
       -
                   <Text

     

       260
       260
       -
                     variant="text-md/normal"

     

       261
       261
       -
                     class={MarkupClasses.markup}

     

       262
       262
       -
                     style={{ width: "100%" }}

     

       263
       263
       -
                   >

     

       207
       207
       +
                   <Text variant="text-md/normal" class={MarkupClasses.markup} style={{ width: "100%" }}>

     

       264
       208
        
                     {MarkupUtils.parse(description ?? "*No description*", true, {

     

       265
       209
        
                       allowHeading: true,

     

       266
       210
        
                       allowLinks: true,

+17 -67

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

···

       30
       30
        
       export const defaultFilter = 127 as Filter;

     

       31
       31
        
       

     

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

     

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

     

       34
       34
       -
         .exports;

     

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

     

       35
       34
        
       

     

       36
       35
        
       let FilterDialogClasses: any;

     

       37
       36
        
       let FilterBarClasses: any;

     

       38
       37
        
       spacepack

     

       39
       39
       -
         .lazyLoad(

     

       40
       40
       -
           '"Missing channel in Channel.openChannelContextMenu"',

     

       41
       41
       -
           /e\("(\d+)"\)/g,

     

       42
       42
       -
           /webpackId:(\d+?),/

     

       43
       43
       -
         )

     

       38
       38
       +
         .lazyLoad('"Missing channel in Channel.openChannelContextMenu"', /e\("(\d+)"\)/g, /webpackId:(\d+?),/)

     

       44
       39
        
         .then(() => {

     

       45
       40
        
           FilterBarClasses = spacepack.findByCode("tagsButtonWithCount:")[0].exports;

     

       46
       46
       -
           FilterDialogClasses = spacepack.findByCode(

     

       47
       47
       -
             "countContainer:",

     

       48
       48
       -
             "tagContainer:"

     

       49
       49
       -
           )[0].exports;

     

       41
       41
       +
           FilterDialogClasses = spacepack.findByCode("countContainer:", "tagContainer:")[0].exports;

     

       50
       42
        
         });

     

       51
       43
        
       

     

       52
       52
       -
       const TagItem = spacepack.findByCode(".FORUM_TAG_A11Y_FILTER_BY_TAG")[0].exports

     

       53
       53
       -
         .Z;

     

       44
       44
       +
       const TagItem = spacepack.findByCode(".FORUM_TAG_A11Y_FILTER_BY_TAG")[0].exports.Z;

     

       54
       45
        
       

     

       55
       46
        
       // FIXME: type component keys

     

       56
       56
       -
       const { ChevronSmallDownIcon, ChevronSmallUpIcon, ArrowsUpDownIcon } =

     

       57
       57
       -
         Components;

     

       47
       47
       +
       const { ChevronSmallDownIcon, ChevronSmallUpIcon, ArrowsUpDownIcon } = Components;

     

       58
       48
        
       

     

       59
       59
       -
       function toggleTag(

     

       60
       60
       -
         selectedTags: Set<string>,

     

       61
       61
       -
         setSelectedTags: (tags: Set<string>) => void,

     

       62
       62
       -
         tag: string

     

       63
       63
       -
       ) {

     

       49
       49
       +
       function toggleTag(selectedTags: Set<string>, setSelectedTags: (tags: Set<string>) => void, tag: string) {

     

       64
       50
        
         const newState = new Set(selectedTags);

     

       65
       51
        
         if (newState.has(tag)) newState.delete(tag);

     

       66
       52
        
         else newState.add(tag);

     
···

       76
       62
        
         setFilter: (filter: Filter) => void;

     

       77
       63
        
         closePopout: () => void;

     

       78
       64
        
       }) {

     

       79
       79
       -
         const toggleFilter = (set: Filter) =>

     

       80
       80
       -
           setFilter(filter & set ? filter & ~set : filter | set);

     

       65
       65
       +
         const toggleFilter = (set: Filter) => setFilter(filter & set ? filter & ~set : filter | set);

     

       81
       66
        
       

     

       82
       67
        
         return (

     

       83
       68
        
           <div className={SortMenuClasses.container}>

     
···

       156
       141
        
         );

     

       157
       142
        
       }

     

       158
       143
        
       

     

       159
       159
       -
       function TagButtonPopout({

     

       160
       160
       -
         selectedTags,

     

       161
       161
       -
         setSelectedTags,

     

       162
       162
       -
         setPopoutRef,

     

       163
       163
       -
         closePopout

     

       164
       164
       -
       }: any) {

     

       144
       144
       +
       function TagButtonPopout({ selectedTags, setSelectedTags, setPopoutRef, closePopout }: any) {

     

       165
       145
        
         return (

     

       166
       146
        
           <Dialog ref={setPopoutRef} className={FilterDialogClasses.container}>

     

       167
       147
        
             <div className={FilterDialogClasses.header}>

     

       168
       148
        
               <div className={FilterDialogClasses.headerLeft}>

     

       169
       169
       -
                 <Heading

     

       170
       170
       -
                   color="interactive-normal"

     

       171
       171
       -
                   variant="text-xs/bold"

     

       172
       172
       -
                   className={FilterDialogClasses.headerText}

     

       173
       173
       -
                 >

     

       149
       149
       +
                 <Heading color="interactive-normal" variant="text-xs/bold" className={FilterDialogClasses.headerText}>

     

       174
       150
        
                   Select tags

     

       175
       151
        
                 </Heading>

     

       176
       152
        
                 <div className={FilterDialogClasses.countContainer}>

     

       177
       177
       -
                   <Text

     

       178
       178
       -
                     className={FilterDialogClasses.countText}

     

       179
       179
       -
                     color="none"

     

       180
       180
       -
                     variant="text-xs/medium"

     

       181
       181
       -
                   >

     

       153
       153
       +
                   <Text className={FilterDialogClasses.countText} color="none" variant="text-xs/medium">

     

       182
       154
        
                     {selectedTags.size}

     

       183
       155
        
                   </Text>

     

       184
       156
        
                 </div>

     
···

       225
       197
        
         selectedTags: Set<string>;

     

       226
       198
        
         setSelectedTags: (tags: Set<string>) => void;

     

       227
       199
        
       }) {

     

       228
       228
       -
         const windowSize = useStateFromStores([WindowStore], () =>

     

       229
       229
       -
           WindowStore.windowSize()

     

       230
       230
       -
         );

     

       200
       200
       +
         const windowSize = useStateFromStores([WindowStore], () => WindowStore.windowSize());

     

       231
       201
        
       

     

       232
       202
        
         const tagsContainer = React.useRef<HTMLDivElement>(null);

     

       233
       203
        
         const tagListInner = React.useRef<HTMLDivElement>(null);

     

       234
       204
        
         const [tagsButtonOffset, setTagsButtonOffset] = React.useState(0);

     

       235
       205
        
         React.useLayoutEffect(() => {

     

       236
       206
        
           if (tagsContainer.current === null || tagListInner.current === null) return;

     

       237
       237
       -
           const { left: containerX, top: containerY } =

     

       238
       238
       -
             tagsContainer.current.getBoundingClientRect();

     

       207
       207
       +
           const { left: containerX, top: containerY } = tagsContainer.current.getBoundingClientRect();

     

       239
       208
        
           let offset = 0;

     

       240
       209
        
           for (const child of tagListInner.current.children) {

     

       241
       241
       -
             const {

     

       242
       242
       -
               right: childX,

     

       243
       243
       -
               top: childY,

     

       244
       244
       -
               height

     

       245
       245
       -
             } = child.getBoundingClientRect();

     

       210
       210
       +
             const { right: childX, top: childY, height } = child.getBoundingClientRect();

     

       246
       211
        
             if (childY - containerY > height) break;

     

       247
       212
        
             const newOffset = childX - containerX;

     

       248
       213
        
             if (newOffset > offset) {

     
···

       262
       227
        
           >

     

       263
       228
        
             <Popout

     

       264
       229
        
               renderPopout={({ closePopout }: any) => (

     

       265
       265
       -
                 <FilterButtonPopout

     

       266
       266
       -
                   filter={filter}

     

       267
       267
       -
                   setFilter={setFilter}

     

       268
       268
       -
                   closePopout={closePopout}

     

       269
       269
       -
                 />

     

       230
       230
       +
                 <FilterButtonPopout filter={filter} setFilter={setFilter} closePopout={closePopout} />

     

       270
       231
        
               )}

     

       271
       232
        
               position="bottom"

     

       272
       233
        
               align="left"

     
···

       280
       241
        
                   innerClassName={FilterBarClasses.sortDropdownInner}

     

       281
       242
        
                 >

     

       282
       243
        
                   <ArrowsUpDownIcon size="xs" />

     

       283
       283
       -
                   <Text

     

       284
       284
       -
                     className={FilterBarClasses.sortDropdownText}

     

       285
       285
       -
                     variant="text-sm/medium"

     

       286
       286
       -
                     color="interactive-normal"

     

       287
       287
       -
                   >

     

       244
       244
       +
                   <Text className={FilterBarClasses.sortDropdownText} variant="text-sm/medium" color="interactive-normal">

     

       288
       245
        
                     Sort & filter

     

       289
       246
        
                   </Text>

     

       290
       247
        
                   {isShown ? (

     
···

       336
       293
        
                   innerClassName={FilterBarClasses.tagsButtonInner}

     

       337
       294
        
                 >

     

       338
       295
        
                   {selectedTags.size > 0 ? (

     

       339
       339
       -
                     <div

     

       340
       340
       -
                       style={{ boxSizing: "content-box" }}

     

       341
       341
       -
                       className={FilterBarClasses.countContainer}

     

       342
       342
       -
                     >

     

       343
       343
       -
                       <Text

     

       344
       344
       -
                         className={FilterBarClasses.countText}

     

       345
       345
       -
                         color="none"

     

       346
       346
       -
                         variant="text-xs/medium"

     

       347
       347
       -
                       >

     

       296
       296
       +
                     <div style={{ boxSizing: "content-box" }} className={FilterBarClasses.countContainer}>

     

       297
       297
       +
                       <Text className={FilterBarClasses.countText} color="none" variant="text-xs/medium">

     

       348
       298
        
                         {selectedTags.size}

     

       349
       299
        
                       </Text>

     

       350
       300
        
                     </div>

+18 -48

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

···

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

     

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

     

       12
       12
        
       

     

       13
       13
       -
       const SearchBar: any = Object.values(

     

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

     

       15
       15
       -
       )[0];

     

       13
       13
       +
       const SearchBar: any = Object.values(spacepack.findByCode("Messages.SEARCH", "hideSearchIcon")[0].exports)[0];

     

       16
       14
        
       

     

       17
       15
        
       export default function ExtensionsPage() {

     

       18
       18
       -
         const { extensions, savedFilter } = useStateFromStoresObject(

     

       19
       19
       -
           [MoonbaseSettingsStore],

     

       20
       20
       -
           () => {

     

       21
       21
       -
             return {

     

       22
       22
       -
               extensions: MoonbaseSettingsStore.extensions,

     

       23
       23
       -
               savedFilter: MoonbaseSettingsStore.getExtensionConfigRaw<number>(

     

       24
       24
       -
                 "moonbase",

     

       25
       25
       -
                 "filter",

     

       26
       26
       -
                 defaultFilter

     

       27
       27
       -
               )

     

       28
       28
       -
             };

     

       29
       29
       -
           }

     

       30
       30
       -
         );

     

       16
       16
       +
         const { extensions, savedFilter } = useStateFromStoresObject([MoonbaseSettingsStore], () => {

     

       17
       17
       +
           return {

     

       18
       18
       +
             extensions: MoonbaseSettingsStore.extensions,

     

       19
       19
       +
             savedFilter: MoonbaseSettingsStore.getExtensionConfigRaw<number>("moonbase", "filter", defaultFilter)

     

       20
       20
       +
           };

     

       21
       21
       +
         });

     

       31
       22
        
       

     

       32
       23
        
         const [query, setQuery] = React.useState("");

     

       33
       24
        
       

     

       34
       25
        
         const filterState = React.useState(defaultFilter);

     

       35
       26
        
       

     

       36
       27
        
         let filter: Filter, setFilter: (filter: Filter) => void;

     

       37
       37
       -
         if (

     

       38
       38
       -
           MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       39
       39
       -
             "moonbase",

     

       40
       40
       -
             "saveFilter",

     

       41
       41
       -
             false

     

       42
       42
       -
           )

     

       43
       43
       -
         ) {

     

       28
       28
       +
         if (MoonbaseSettingsStore.getExtensionConfigRaw<boolean>("moonbase", "saveFilter", false)) {

     

       44
       29
        
           filter = savedFilter ?? defaultFilter;

     

       45
       45
       -
           setFilter = (filter) =>

     

       46
       46
       -
             MoonbaseSettingsStore.setExtensionConfig("moonbase", "filter", filter);

     

       30
       30
       +
           setFilter = (filter) => MoonbaseSettingsStore.setExtensionConfig("moonbase", "filter", filter);

     

       47
       31
        
         } else {

     

       48
       32
        
           filter = filterState[0];

     

       49
       33
        
           setFilter = filterState[1];

     
···

       62
       46
        
               ext.manifest.meta?.name?.toLowerCase().includes(query) ||

     

       63
       47
        
               ext.manifest.meta?.tagline?.toLowerCase().includes(query) ||

     

       64
       48
        
               ext.manifest.meta?.description?.toLowerCase().includes(query)) &&

     

       65
       65
       -
             [...selectedTags.values()].every(

     

       66
       66
       -
               (tag) => ext.manifest.meta?.tags?.includes(tag as ExtensionTag)

     

       67
       67
       -
             ) &&

     

       49
       49
       +
             [...selectedTags.values()].every((tag) => ext.manifest.meta?.tags?.includes(tag as ExtensionTag)) &&

     

       68
       50
        
             // This seems very bad, sorry

     

       69
       51
        
             !(

     

       70
       70
       -
               (!(filter & Filter.Core) &&

     

       71
       71
       -
                 ext.source.type === ExtensionLoadSource.Core) ||

     

       72
       72
       -
               (!(filter & Filter.Normal) &&

     

       73
       73
       -
                 ext.source.type === ExtensionLoadSource.Normal) ||

     

       74
       74
       -
               (!(filter & Filter.Developer) &&

     

       75
       75
       -
                 ext.source.type === ExtensionLoadSource.Developer) ||

     

       76
       76
       -
               (!(filter & Filter.Enabled) &&

     

       77
       77
       -
                 MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       78
       78
       -
               (!(filter & Filter.Disabled) &&

     

       79
       79
       -
                 !MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       80
       80
       -
               (!(filter & Filter.Installed) &&

     

       81
       81
       -
                 ext.state !== ExtensionState.NotDownloaded) ||

     

       82
       82
       -
               (!(filter & Filter.Repository) &&

     

       83
       83
       -
                 ext.state === ExtensionState.NotDownloaded)

     

       52
       52
       +
               (!(filter & Filter.Core) && ext.source.type === ExtensionLoadSource.Core) ||

     

       53
       53
       +
               (!(filter & Filter.Normal) && ext.source.type === ExtensionLoadSource.Normal) ||

     

       54
       54
       +
               (!(filter & Filter.Developer) && ext.source.type === ExtensionLoadSource.Developer) ||

     

       55
       55
       +
               (!(filter & Filter.Enabled) && MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       56
       56
       +
               (!(filter & Filter.Disabled) && !MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       57
       57
       +
               (!(filter & Filter.Installed) && ext.state !== ExtensionState.NotDownloaded) ||

     

       58
       58
       +
               (!(filter & Filter.Repository) && ext.state === ExtensionState.NotDownloaded)

     

       84
       59
        
             ) &&

     

       85
       60
        
             (filter & Filter.Incompatible ||

     

       86
       61
        
               ext.compat === ExtensionCompat.Compatible ||

     
···

       102
       77
        
                 spellCheck: "false"

     

       103
       78
        
               }}

     

       104
       79
        
             />

     

       105
       105
       -
             <FilterBar

     

       106
       106
       -
               filter={filter}

     

       107
       107
       -
               setFilter={setFilter}

     

       108
       108
       -
               selectedTags={selectedTags}

     

       109
       109
       -
               setSelectedTags={setSelectedTags}

     

       110
       110
       -
             />

     

       80
       80
       +
             <FilterBar filter={filter} setFilter={setFilter} selectedTags={selectedTags} setSelectedTags={setSelectedTags} />

     

       111
       81
        
             {filtered.map((ext) => (

     

       112
       82
        
               <ExtensionCard uniqueId={ext.uniqueId} key={ext.uniqueId} />

     

       113
       83
        
             ))}

+4 -27

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

···

       34
       34
        
         [ExtensionTag.Library]: "Library"

     

       35
       35
        
       };

     

       36
       36
        
       

     

       37
       37
       -
       const UserInfoClasses = spacepack.findByCode(

     

       38
       38
       -
         "infoScroller",

     

       39
       39
       -
         "userInfoSection",

     

       40
       40
       -
         "userInfoSectionHeader"

     

       41
       41
       -
       )[0].exports;

     

       37
       37
       +
       const UserInfoClasses = spacepack.findByCode("infoScroller", "userInfoSection", "userInfoSectionHeader")[0].exports;

     

       42
       38
        
       

     

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

     

       44
       40
        
       

     

       45
       41
        
       // FIXME: type component keys

     

       46
       42
        
       const { Text } = Components;

     

       47
       43
        
       

     

       48
       48
       -
       function InfoSection({

     

       49
       49
       -
         title,

     

       50
       50
       -
         children

     

       51
       51
       -
       }: {

     

       52
       52
       -
         title: string;

     

       53
       53
       -
         children: React.ReactNode;

     

       54
       54
       -
       }) {

     

       44
       44
       +
       function InfoSection({ title, children }: { title: string; children: React.ReactNode }) {

     

       55
       45
        
         return (

     

       56
       46
        
           <div

     

       57
       47
        
             style={{

     
···

       67
       57
        
         );

     

       68
       58
        
       }

     

       69
       59
        
       

     

       70
       70
       -
       function Badge({

     

       71
       71
       -
         color,

     

       72
       72
       -
         children

     

       73
       73
       -
       }: {

     

       74
       74
       -
         color: string;

     

       75
       75
       -
         children: React.ReactNode;

     

       76
       76
       -
       }) {

     

       60
       60
       +
       function Badge({ color, children }: { color: string; children: React.ReactNode }) {

     

       77
       61
        
         return (

     

       78
       62
        
           <span

     

       79
       63
        
             style={{

     
···

       154
       138
        
                   const name = tagNames[tag];

     

       155
       139
        
       

     

       156
       140
        
                   return (

     

       157
       157
       -
                     <Badge

     

       158
       158
       -
                       key={i}

     

       159
       159
       -
                       color={

     

       160
       160
       -
                         tag === ExtensionTag.DangerZone

     

       161
       161
       -
                           ? "var(--red-400)"

     

       162
       162
       -
                           : "var(--brand-500)"

     

       163
       163
       -
                       }

     

       164
       164
       -
                     >

     

       141
       141
       +
                     <Badge key={i} color={tag === ExtensionTag.DangerZone ? "var(--red-400)" : "var(--brand-500)"}>

     

       165
       142
        
                       {name}

     

       166
       143
        
                     </Badge>

     

       167
       144
        
                   );

+27 -102

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

···

       33
       33
        
           () => {

     

       34
       34
        
             return {

     

       35
       35
        
               value: MoonbaseSettingsStore.getExtensionConfig<T>(uniqueId, name),

     

       36
       36
       -
               displayName: MoonbaseSettingsStore.getExtensionConfigName(

     

       37
       37
       -
                 uniqueId,

     

       38
       38
       -
                 name

     

       39
       39
       -
               ),

     

       40
       40
       -
               description: MoonbaseSettingsStore.getExtensionConfigDescription(

     

       41
       41
       -
                 uniqueId,

     

       42
       42
       -
                 name

     

       43
       43
       -
               )

     

       36
       36
       +
               displayName: MoonbaseSettingsStore.getExtensionConfigName(uniqueId, name),

     

       37
       37
       +
               description: MoonbaseSettingsStore.getExtensionConfigDescription(uniqueId, name)

     

       44
       38
        
             };

     

       45
       39
        
           },

     

       46
       40
        
           [uniqueId, name]

     
···

       49
       43
        
       

     

       50
       44
        
       function Boolean({ ext, name, setting, disabled }: SettingsProps) {

     

       51
       45
        
         const { FormSwitch } = Components;

     

       52
       52
       -
         const { value, displayName, description } = useConfigEntry<boolean>(

     

       53
       53
       -
           ext.uniqueId,

     

       54
       54
       -
           name

     

       55
       55
       -
         );

     

       46
       46
       +
         const { value, displayName, description } = useConfigEntry<boolean>(ext.uniqueId, name);

     

       56
       47
        
       

     

       57
       48
        
         return (

     

       58
       49
        
           <FormSwitch

     
···

       72
       63
        
       

     

       73
       64
        
       function Number({ ext, name, setting, disabled }: SettingsProps) {

     

       74
       65
        
         const { FormItem, FormText, Slider } = Components;

     

       75
       75
       -
         const { value, displayName, description } = useConfigEntry<number>(

     

       76
       76
       -
           ext.uniqueId,

     

       77
       77
       -
           name

     

       78
       78
       -
         );

     

       66
       66
       +
         const { value, displayName, description } = useConfigEntry<number>(ext.uniqueId, name);

     

       79
       67
        
       

     

       80
       68
        
         const castedSetting = setting as NumberSettingType;

     

       81
       69
        
         const min = castedSetting.min ?? 0;

     
···

       100
       88
        
       

     

       101
       89
        
       function String({ ext, name, setting, disabled }: SettingsProps) {

     

       102
       90
        
         const { FormItem, FormText, TextInput } = Components;

     

       103
       103
       -
         const { value, displayName, description } = useConfigEntry<string>(

     

       104
       104
       -
           ext.uniqueId,

     

       105
       105
       -
           name

     

       106
       106
       -
         );

     

       91
       91
       +
         const { value, displayName, description } = useConfigEntry<string>(ext.uniqueId, name);

     

       107
       92
        
       

     

       108
       93
        
         return (

     

       109
       94
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       110
       110
       -
             {description && (

     

       111
       111
       -
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       112
       112
       -
             )}

     

       95
       95
       +
             {description && <FormText className={Margins.marginBottom8}>{description}</FormText>}

     

       113
       96
        
             <TextInput

     

       114
       97
        
               value={value ?? ""}

     

       115
       98
        
               onChange={(value: string) => {

     
···

       123
       106
        
       

     

       124
       107
        
       function MultilineString({ ext, name, setting, disabled }: SettingsProps) {

     

       125
       108
        
         const { FormItem, FormText, TextArea } = Components;

     

       126
       126
       -
         const { value, displayName, description } = useConfigEntry<string>(

     

       127
       127
       -
           ext.uniqueId,

     

       128
       128
       -
           name

     

       129
       129
       -
         );

     

       109
       109
       +
         const { value, displayName, description } = useConfigEntry<string>(ext.uniqueId, name);

     

       130
       110
        
       

     

       131
       111
        
         return (

     

       132
       112
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       133
       133
       -
             {description && (

     

       134
       134
       -
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       135
       135
       -
             )}

     

       113
       113
       +
             {description && <FormText className={Margins.marginBottom8}>{description}</FormText>}

     

       136
       114
        
             <TextArea

     

       137
       115
        
               rows={5}

     

       138
       116
        
               value={value ?? ""}

     
···

       148
       126
        
       

     

       149
       127
        
       function Select({ ext, name, setting, disabled }: SettingsProps) {

     

       150
       128
        
         const { FormItem, FormText, SingleSelect } = Components;

     

       151
       151
       -
         const { value, displayName, description } = useConfigEntry<string>(

     

       152
       152
       -
           ext.uniqueId,

     

       153
       153
       -
           name

     

       154
       154
       -
         );

     

       129
       129
       +
         const { value, displayName, description } = useConfigEntry<string>(ext.uniqueId, name);

     

       155
       130
        
       

     

       156
       131
        
         const castedSetting = setting as SelectSettingType;

     

       157
       132
        
         const options = castedSetting.options;

     

       158
       133
        
       

     

       159
       134
        
         return (

     

       160
       135
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       161
       161
       -
             {description && (

     

       162
       162
       -
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       163
       163
       -
             )}

     

       136
       136
       +
             {description && <FormText className={Margins.marginBottom8}>{description}</FormText>}

     

       164
       137
        
             <SingleSelect

     

       165
       138
        
               autofocus={false}

     

       166
       139
        
               clearable={false}

     

       167
       140
        
               value={value ?? ""}

     

       168
       168
       -
               options={options.map((o: SelectOption) =>

     

       169
       169
       -
                 typeof o === "string" ? { value: o, label: o } : o

     

       170
       170
       -
               )}

     

       141
       141
       +
               options={options.map((o: SelectOption) => (typeof o === "string" ? { value: o, label: o } : o))}

     

       171
       142
        
               onChange={(value: string) => {

     

       172
       143
        
                 if (disabled) return;

     

       173
       144
        
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     
···

       178
       149
        
       }

     

       179
       150
        
       

     

       180
       151
        
       function MultiSelect({ ext, name, setting, disabled }: SettingsProps) {

     

       181
       181
       -
         const { FormItem, FormText, Select, useVariableSelect, multiSelect } =

     

       182
       182
       -
           Components;

     

       183
       183
       -
         const { value, displayName, description } = useConfigEntry<string | string[]>(

     

       184
       184
       -
           ext.uniqueId,

     

       185
       185
       -
           name

     

       186
       186
       -
         );

     

       152
       152
       +
         const { FormItem, FormText, Select, useVariableSelect, multiSelect } = Components;

     

       153
       153
       +
         const { value, displayName, description } = useConfigEntry<string | string[]>(ext.uniqueId, name);

     

       187
       154
        
       

     

       188
       155
        
         const castedSetting = setting as MultiSelectSettingType;

     

       189
       156
        
         const options = castedSetting.options;

     

       190
       157
        
       

     

       191
       158
        
         return (

     

       192
       159
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       193
       193
       -
             {description && (

     

       194
       194
       -
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       195
       195
       -
             )}

     

       160
       160
       +
             {description && <FormText className={Margins.marginBottom8}>{description}</FormText>}

     

       196
       161
        
             <Select

     

       197
       162
        
               autofocus={false}

     

       198
       163
        
               clearable={false}

     

       199
       164
        
               closeOnSelect={false}

     

       200
       200
       -
               options={options.map((o: SelectOption) =>

     

       201
       201
       -
                 typeof o === "string" ? { value: o, label: o } : o

     

       202
       202
       -
               )}

     

       165
       165
       +
               options={options.map((o: SelectOption) => (typeof o === "string" ? { value: o, label: o } : o))}

     

       203
       166
        
               {...useVariableSelect({

     

       204
       167
        
                 onSelectInteraction: multiSelect,

     

       205
       168
        
                 value: new Set(Array.isArray(value) ? value : [value]),

     

       206
       169
        
                 onChange: (value: string) => {

     

       207
       170
        
                   if (disabled) return;

     

       208
       208
       -
                   MoonbaseSettingsStore.setExtensionConfig(

     

       209
       209
       -
                     ext.id,

     

       210
       210
       -
                     name,

     

       211
       211
       -
                     Array.from(value)

     

       212
       212
       -
                   );

     

       171
       171
       +
                   MoonbaseSettingsStore.setExtensionConfig(ext.id, name, Array.from(value));

     

       213
       172
        
                 }

     

       214
       173
        
               })}

     

       215
       174
        
             />

     
···

       217
       176
        
         );

     

       218
       177
        
       }

     

       219
       178
        
       

     

       220
       220
       -
       const RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0]

     

       221
       221
       -
         .exports;

     

       179
       179
       +
       const RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0].exports;

     

       222
       180
        
       

     

       223
       181
        
       // FIXME: type component keys

     

       224
       182
        
       const { CircleXIcon } = Components;

     

       225
       183
        
       

     

       226
       226
       -
       function RemoveEntryButton({

     

       227
       227
       -
         onClick,

     

       228
       228
       -
         disabled

     

       229
       229
       -
       }: {

     

       230
       230
       -
         onClick: () => void;

     

       231
       231
       -
         disabled: boolean;

     

       232
       232
       -
       }) {

     

       184
       184
       +
       function RemoveEntryButton({ onClick, disabled }: { onClick: () => void; disabled: boolean }) {

     

       233
       185
        
         const { Tooltip, Clickable } = Components;

     

       234
       186
        
         return (

     

       235
       187
        
           <div className={RemoveButtonClasses.removeButtonContainer}>

     

       236
       188
        
             <Tooltip text="Remove entry" position="top">

     

       237
       189
        
               {(props: any) => (

     

       238
       238
       -
                 <Clickable

     

       239
       239
       -
                   {...props}

     

       240
       240
       -
                   className={RemoveButtonClasses.removeButton}

     

       241
       241
       -
                   onClick={onClick}

     

       242
       242
       -
                 >

     

       190
       190
       +
                 <Clickable {...props} className={RemoveButtonClasses.removeButton} onClick={onClick}>

     

       243
       191
        
                   <CircleXIcon width={16} height={16} />

     

       244
       192
        
                 </Clickable>

     

       245
       193
        
               )}

     
···

       250
       198
        
       

     

       251
       199
        
       function List({ ext, name, setting, disabled }: SettingsProps) {

     

       252
       200
        
         const { FormItem, FormText, TextInput, Button } = Components;

     

       253
       253
       -
         const { value, displayName, description } = useConfigEntry<string[]>(

     

       254
       254
       -
           ext.uniqueId,

     

       255
       255
       -
           name

     

       256
       256
       -
         );

     

       201
       201
       +
         const { value, displayName, description } = useConfigEntry<string[]>(ext.uniqueId, name);

     

       257
       202
        
       

     

       258
       203
        
         const entries = value ?? [];

     

       259
       259
       -
         const updateConfig = () =>

     

       260
       260
       -
           MoonbaseSettingsStore.setExtensionConfig(ext.id, name, entries);

     

       204
       204
       +
         const updateConfig = () => MoonbaseSettingsStore.setExtensionConfig(ext.id, name, entries);

     

       261
       205
        
       

     

       262
       206
        
         return (

     

       263
       207
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       264
       264
       -
             {description && (

     

       265
       265
       -
               <FormText className={Margins.marginBottom4}>{description}</FormText>

     

       266
       266
       -
             )}

     

       208
       208
       +
             {description && <FormText className={Margins.marginBottom4}>{description}</FormText>}

     

       267
       209
        
             <Flex direction={Flex.Direction.VERTICAL}>

     

       268
       210
        
               {entries.map((val, i) => (

     

       269
       211
        
                 // FIXME: stylesheets

     
···

       316
       258
        
       

     

       317
       259
        
       function Dictionary({ ext, name, setting, disabled }: SettingsProps) {

     

       318
       260
        
         const { FormItem, FormText, TextInput, Button } = Components;

     

       319
       319
       -
         const { value, displayName, description } = useConfigEntry<

     

       320
       320
       -
           Record<string, string>

     

       321
       321
       -
         >(ext.uniqueId, name);

     

       261
       261
       +
         const { value, displayName, description } = useConfigEntry<Record<string, string>>(ext.uniqueId, name);

     

       322
       262
        
       

     

       323
       263
        
         const entries = Object.entries(value ?? {});

     

       324
       324
       -
         const updateConfig = () =>

     

       325
       325
       -
           MoonbaseSettingsStore.setExtensionConfig(

     

       326
       326
       -
             ext.id,

     

       327
       327
       -
             name,

     

       328
       328
       -
             Object.fromEntries(entries)

     

       329
       329
       -
           );

     

       264
       264
       +
         const updateConfig = () => MoonbaseSettingsStore.setExtensionConfig(ext.id, name, Object.fromEntries(entries));

     

       330
       265
        
       

     

       331
       266
        
         return (

     

       332
       267
        
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       333
       333
       -
             {description && (

     

       334
       334
       -
               <FormText className={Margins.marginBottom4}>{description}</FormText>

     

       335
       335
       -
             )}

     

       268
       268
       +
             {description && <FormText className={Margins.marginBottom4}>{description}</FormText>}

     

       336
       269
        
             <Flex direction={Flex.Direction.VERTICAL}>

     

       337
       270
        
               {entries.map(([key, val], i) => (

     

       338
       271
        
                 // FIXME: stylesheets

     
···

       399
       332
        
           [MoonbaseSettingsStore],

     

       400
       333
        
           () => {

     

       401
       334
        
             return {

     

       402
       402
       -
               component: MoonbaseSettingsStore.getExtensionConfigComponent(

     

       403
       403
       -
                 ext.id,

     

       404
       404
       -
                 name

     

       405
       405
       -
               )

     

       335
       335
       +
               component: MoonbaseSettingsStore.getExtensionConfigComponent(ext.id, name)

     

       406
       336
        
             };

     

       407
       337
        
           },

     

       408
       338
        
           [ext.uniqueId, name]

     
···

       416
       346
        
         }

     

       417
       347
        
       

     

       418
       348
        
         return (

     

       419
       419
       -
           <Component

     

       420
       420
       -
             value={value}

     

       421
       421
       -
             setValue={(value) =>

     

       422
       422
       -
               MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value)

     

       423
       423
       -
             }

     

       424
       424
       -
           />

     

       349
       349
       +
           <Component value={value} setValue={(value) => MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value)} />

     

       425
       350
        
         );

     

       426
       351
        
       }

     

       427
       352

+6 -25

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

···

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

     

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

     

       3
       3
       -
       import {

     

       4
       4
       -
         Text,

     

       5
       5
       -
         TabBar

     

       6
       6
       -
       } from "@moonlight-mod/wp/discord/components/common/index";

     

       3
       3
       +
       import { Text, TabBar } from "@moonlight-mod/wp/discord/components/common/index";

     

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

     

       8
       5
        
       import { UserSettingsModalStore } from "@moonlight-mod/wp/common_stores";

     

       9
       6
        
       

     
···

       12
       9
        
       import Update from "./update";

     

       13
       10
        
       

     

       14
       11
        
       const { Divider } = spacepack.findByCode(".forumOrHome]:")[0].exports.Z;

     

       15
       15
       -
       const TitleBarClasses = spacepack.findByCode("iconWrapper:", "children:")[0]

     

       16
       16
       -
         .exports;

     

       12
       12
       +
       const TitleBarClasses = spacepack.findByCode("iconWrapper:", "children:")[0].exports;

     

       17
       13
        
       const TabBarClasses = spacepack.findByCode("nowPlayingColumn:")[0].exports;

     

       18
       18
       -
       const { setSection, clearSubsection } = spacepack.findByExports(

     

       19
       19
       -
         "setSection",

     

       20
       20
       -
         "clearSubsection"

     

       21
       21
       -
       )[0].exports.Z;

     

       14
       14
       +
       const { setSection, clearSubsection } = spacepack.findByExports("setSection", "clearSubsection")[0].exports.Z;

     

       22
       15
        
       const Margins = spacepack.require("discord/styles/shared/Margins.css");

     

       23
       16
        
       

     

       24
       17
        
       export const pages: {

     
···

       39
       32
        
       ];

     

       40
       33
        
       

     

       41
       34
        
       export function Moonbase(props: { initialTab?: number } = {}) {

     

       42
       42
       -
         const subsection = useStateFromStores(

     

       43
       43
       -
           [UserSettingsModalStore],

     

       44
       44
       -
           () => UserSettingsModalStore.getSubsection() ?? 0

     

       45
       45
       -
         );

     

       35
       35
       +
         const subsection = useStateFromStores([UserSettingsModalStore], () => UserSettingsModalStore.getSubsection() ?? 0);

     

       46
       36
        
         const setSubsection = React.useCallback(

     

       47
       37
        
           (to: string) => {

     

       48
       38
        
             if (subsection !== to) setSection("moonbase", to);

     
···

       61
       51
        
         return (

     

       62
       52
        
           <>

     

       63
       53
        
             <div className={`${TitleBarClasses.children} ${Margins.marginBottom20}`}>

     

       64
       64
       -
               <Text

     

       65
       65
       -
                 className={TitleBarClasses.titleWrapper}

     

       66
       66
       -
                 variant="heading-lg/semibold"

     

       67
       67
       -
                 tag="h2"

     

       68
       68
       -
               >

     

       54
       54
       +
               <Text className={TitleBarClasses.titleWrapper} variant="heading-lg/semibold" tag="h2">

     

       69
       55
        
                 Moonbase

     

       70
       56
        
               </Text>

     

       71
       57
        
               <Divider />

     

       72
       72
       -
               <TabBar

     

       73
       73
       -
                 selectedItem={subsection}

     

       74
       74
       -
                 onItemSelect={setSubsection}

     

       75
       75
       -
                 type="top-pill"

     

       76
       76
       -
                 className={TabBarClasses.tabBar}

     

       77
       77
       -
               >

     

       58
       58
       +
               <TabBar selectedItem={subsection} onItemSelect={setSubsection} type="top-pill" className={TabBarClasses.tabBar}>

     

       78
       59
        
                 {pages.map((page, i) => (

     

       79
       60
        
                   <TabBar.Item key={page.id} id={i} className={TabBarClasses.item}>

     

       80
       61
        
                     {page.name}

+5 -18

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

···

       14
       14
        
       

     

       15
       15
        
       const { ThemeDarkIcon, Text, Button } = Components;

     

       16
       16
        
       const Margins = spacepack.require("discord/styles/shared/Margins.css");

     

       17
       17
       -
       const HelpMessageClasses = spacepack.findByExports("positive", "iconDiv")[0]

     

       18
       18
       -
         .exports;

     

       17
       17
       +
       const HelpMessageClasses = spacepack.findByExports("positive", "iconDiv")[0].exports;

     

       19
       18
        
       

     

       20
       19
        
       const logger = moonlight.getLogger("moonbase/ui/update");

     

       21
       20
        
       

     
···

       23
       22
        
         [UpdateState.Ready]: "A new version of moonlight is available.",

     

       24
       23
        
         [UpdateState.Working]: "Updating moonlight...",

     

       25
       24
        
         [UpdateState.Installed]: "Updated. Restart Discord to apply changes.",

     

       26
       26
       -
         [UpdateState.Failed]:

     

       27
       27
       -
           "Failed to update moonlight. Please use the installer instead."

     

       25
       25
       +
         [UpdateState.Failed]: "Failed to update moonlight. Please use the installer instead."

     

       28
       26
        
       };

     

       29
       27
        
       

     

       30
       28
        
       export default function Update() {

     

       31
       29
        
         const [state, setState] = React.useState(UpdateState.Ready);

     

       32
       32
       -
         const newVersion = useStateFromStores(

     

       33
       33
       -
           [MoonbaseSettingsStore],

     

       34
       34
       -
           () => MoonbaseSettingsStore.newVersion

     

       35
       35
       -
         );

     

       30
       30
       +
         const newVersion = useStateFromStores([MoonbaseSettingsStore], () => MoonbaseSettingsStore.newVersion);

     

       36
       31
        
       

     

       37
       32
        
         if (newVersion == null) return null;

     

       38
       33
        
       

     
···

       48
       43
        
                   alignItems: "center"

     

       49
       44
        
                 }}

     

       50
       45
        
               >

     

       51
       51
       -
                 <ThemeDarkIcon

     

       52
       52
       -
                   size="sm"

     

       53
       53
       -
                   color="currentColor"

     

       54
       54
       -
                   className={HelpMessageClasses.icon}

     

       55
       55
       -
                 />

     

       46
       46
       +
                 <ThemeDarkIcon size="sm" color="currentColor" className={HelpMessageClasses.icon} />

     

       56
       47
        
               </div>

     

       57
       48
        
       

     

       58
       58
       -
               <Text

     

       59
       59
       -
                 variant="text-sm/medium"

     

       60
       60
       -
                 color="currentColor"

     

       61
       61
       -
                 className={HelpMessageClasses.text}

     

       62
       62
       -
               >

     

       49
       49
       +
               <Text variant="text-sm/medium" color="currentColor" className={HelpMessageClasses.text}>

     

       63
       50
        
                 {strings[state]}

     

       64
       51
        
               </Text>

     

       65
       52
        
             </Flex>

+5 -23

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

···

       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
       -
       );

     

       10
       10
       +
       const UserSettingsSections = spacepack.findObjectFromKey(Constants, "APPEARANCE_THEME_PICKER");

     

       14
       11
        
       

     

       15
       12
        
       const { ThemeDarkIcon } = Components;

     

       16
       13
        
       

     
···

       21
       18
        
       function listener() {

     

       22
       19
        
         if (

     

       23
       20
        
           MoonbaseSettingsStore.shouldShowNotice &&

     

       24
       24
       -
           MoonbaseSettingsStore.getExtensionConfigRaw(

     

       25
       25
       -
             "moonbase",

     

       26
       26
       -
             "updateBanner",

     

       27
       27
       -
             true

     

       28
       28
       -
           )

     

       21
       21
       +
           MoonbaseSettingsStore.getExtensionConfigRaw("moonbase", "updateBanner", true)

     

       29
       22
        
         ) {

     

       30
       23
        
           // @ts-expect-error epic type fail

     

       31
       24
        
           MoonbaseSettingsStore.removeChangeListener(listener);

     

       32
       25
        
       

     

       33
       26
        
           const version = MoonbaseSettingsStore.newVersion;

     

       34
       34
       -
           const extensionUpdateCount = Object.keys(

     

       35
       35
       -
             MoonbaseSettingsStore.updates

     

       36
       36
       -
           ).length;

     

       27
       27
       +
           const extensionUpdateCount = Object.keys(MoonbaseSettingsStore.updates).length;

     

       37
       28
        
           const hasExtensionUpdates = extensionUpdateCount > 0;

     

       38
       29
        
       

     

       39
       30
        
           let message;

     
···

       73
       64
        
               {

     

       74
       65
        
                 name: "Open Moonbase",

     

       75
       66
        
                 onClick: () => {

     

       76
       76
       -
                   const { open } = spacepack.findByExports(

     

       77
       77
       -
                     "setSection",

     

       78
       78
       -
                     "clearSubsection"

     

       79
       79
       -
                   )[0].exports.Z;

     

       67
       67
       +
                   const { open } = spacepack.findByExports("setSection", "clearSubsection")[0].exports.Z;

     

       80
       68
        
       

     

       81
       69
        
                   // settings is lazy loaded thus lazily patched

     

       82
       70
        
                   // FIXME: figure out a way to detect if settings has been opened

     

       83
       71
        
                   //        alreadyjust so the transition isnt as jarring

     

       84
       72
        
                   open(UserSettingsSections.ACCOUNT);

     

       85
       73
        
                   setTimeout(() => {

     

       86
       86
       -
                     if (

     

       87
       87
       -
                       MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       88
       88
       -
                         "moonbase",

     

       89
       89
       -
                         "sections",

     

       90
       90
       -
                         false

     

       91
       91
       -
                       )

     

       92
       92
       -
                     ) {

     

       74
       74
       +
                     if (MoonbaseSettingsStore.getExtensionConfigRaw<boolean>("moonbase", "sections", false)) {

     

       93
       75
        
                       open("moonbase-extensions");

     

       94
       76
        
                     } else {

     

       95
       77
        
                       open("moonbase", 0);

+9 -42

packages/core-extensions/src/nativeFixes/host.ts

···

       1
       1
        
       import { app, nativeTheme } from "electron";

     

       2
       2
        
       

     

       3
       3
       -
       const enabledFeatures = app.commandLine

     

       4
       4
       -
         .getSwitchValue("enable-features")

     

       5
       5
       -
         .split(",");

     

       3
       3
       +
       const enabledFeatures = app.commandLine.getSwitchValue("enable-features").split(",");

     

       6
       4
        
       

     

       7
       5
        
       moonlightHost.events.on("window-created", function (browserWindow) {

     

       8
       8
       -
         if (

     

       9
       9
       -
           moonlightHost.getConfigOption<boolean>("nativeFixes", "devtoolsThemeFix") ??

     

       10
       10
       -
           true

     

       11
       11
       -
         ) {

     

       6
       6
       +
         if (moonlightHost.getConfigOption<boolean>("nativeFixes", "devtoolsThemeFix") ?? true) {

     

       12
       7
        
           browserWindow.webContents.on("devtools-opened", () => {

     

       13
       8
        
             if (!nativeTheme.shouldUseDarkColors) return;

     

       14
       9
        
             nativeTheme.themeSource = "light";

     
···

       19
       14
        
         }

     

       20
       15
        
       });

     

       21
       16
        
       

     

       22
       22
       -
       if (

     

       23
       23
       -
         moonlightHost.getConfigOption<boolean>(

     

       24
       24
       -
           "nativeFixes",

     

       25
       25
       -
           "disableRendererBackgrounding"

     

       26
       26
       -
         ) ??

     

       27
       27
       -
         true

     

       28
       28
       -
       ) {

     

       17
       17
       +
       if (moonlightHost.getConfigOption<boolean>("nativeFixes", "disableRendererBackgrounding") ?? true) {

     

       29
       18
        
         // Discord already disables UseEcoQoSForBackgroundProcess and some other

     

       30
       19
        
         // related features

     

       31
       20
        
         app.commandLine.appendSwitch("disable-renderer-backgrounding");

     
···

       36
       25
        
       }

     

       37
       26
        
       

     

       38
       27
        
       if (process.platform === "linux") {

     

       39
       39
       -
         if (

     

       40
       40
       -
           moonlightHost.getConfigOption<boolean>("nativeFixes", "linuxAutoscroll") ??

     

       41
       41
       -
           false

     

       42
       42
       -
         ) {

     

       43
       43
       -
           app.commandLine.appendSwitch(

     

       44
       44
       -
             "enable-blink-features",

     

       45
       45
       -
             "MiddleClickAutoscroll"

     

       46
       46
       -
           );

     

       28
       28
       +
         if (moonlightHost.getConfigOption<boolean>("nativeFixes", "linuxAutoscroll") ?? false) {

     

       29
       29
       +
           app.commandLine.appendSwitch("enable-blink-features", "MiddleClickAutoscroll");

     

       47
       30
        
         }

     

       48
       31
        
       

     

       49
       49
       -
         if (

     

       50
       50
       -
           moonlightHost.getConfigOption<boolean>(

     

       51
       51
       -
             "nativeFixes",

     

       52
       52
       -
             "linuxSpeechDispatcher"

     

       53
       53
       -
           ) ??

     

       54
       54
       -
           true

     

       55
       55
       -
         ) {

     

       32
       32
       +
         if (moonlightHost.getConfigOption<boolean>("nativeFixes", "linuxSpeechDispatcher") ?? true) {

     

       56
       33
        
           app.commandLine.appendSwitch("enable-speech-dispatcher");

     

       57
       34
        
         }

     

       58
       35
        
       }

     
···

       60
       37
        
       // NOTE: Only tested if this appears on Windows, it should appear on all when

     

       61
       38
        
       //       hardware acceleration is disabled

     

       62
       39
        
       const noAccel = app.commandLine.hasSwitch("disable-gpu-compositing");

     

       63
       63
       -
       if (

     

       64
       64
       -
         (moonlightHost.getConfigOption<boolean>("nativeFixes", "vaapi") ?? true) &&

     

       65
       65
       -
         !noAccel

     

       66
       66
       -
       ) {

     

       40
       40
       +
       if ((moonlightHost.getConfigOption<boolean>("nativeFixes", "vaapi") ?? true) && !noAccel) {

     

       67
       41
        
         if (process.platform === "linux")

     

       68
       42
        
           // These will eventually be renamed https://source.chromium.org/chromium/chromium/src/+/5482210941a94d70406b8da962426e4faca7fce4

     

       69
       69
       -
           enabledFeatures.push(

     

       70
       70
       -
             "VaapiVideoEncoder",

     

       71
       71
       -
             "VaapiVideoDecoder",

     

       72
       72
       -
             "VaapiVideoDecodeLinuxGL"

     

       73
       73
       -
           );

     

       43
       43
       +
           enabledFeatures.push("VaapiVideoEncoder", "VaapiVideoDecoder", "VaapiVideoDecodeLinuxGL");

     

       74
       44
        
       }

     

       75
       45
        
       

     

       76
       76
       -
       app.commandLine.appendSwitch(

     

       77
       77
       -
         "enable-features",

     

       78
       78
       -
         [...new Set(enabledFeatures)].join(",")

     

       79
       79
       -
       );

     

       46
       46
       +
       app.commandLine.appendSwitch("enable-features", [...new Set(enabledFeatures)].join(","));

+2 -6

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

···

       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:/,

     

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

     

       9
       8
        
             replacement: (orig, createElement) =>

     

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

     

       11
       10
        
           }

     
···

       28
       27
        
       

     

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

     

       30
       29
        
         notices: {

     

       31
       31
       -
           dependencies: [

     

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

     

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

     

       34
       34
       -
           ]

     

       30
       30
       +
           dependencies: [{ id: "discord/packages/flux" }, { id: "discord/Dispatcher" }]

     

       35
       31
        
         },

     

       36
       32
        
       

     

       37
       33
        
         component: {

+1 -4

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

···

       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
       -
               />

     

       35
       35
       +
               <NoticeCloseButton onClick={() => popAndDismiss(notice)} noticeType="__moonlight_notice" />

     

       39
       36
        
             )}

     

       40
       37
        
       

     

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

+1 -4

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";

     

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

     

       7
       4
        
       

     

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

     

       9
       6
        
       let open = false;

+9 -34

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

···

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

     

       2
       2
        
       

     

       3
       3
        
       const notXssDefensesOnly = () =>

     

       4
       4
       -
         (moonlight.getConfigOption<boolean>("quietLoggers", "xssDefensesOnly") ??

     

       5
       5
       -
           false) === false;

     

       4
       4
       +
         (moonlight.getConfigOption<boolean>("quietLoggers", "xssDefensesOnly") ?? false) === false;

     

       6
       5
        
       

     

       7
       6
        
       // These patches MUST run before the simple patches, these are to remove loggers

     

       8
       7
        
       // that end up causing syntax errors by the normal patch

     
···

       29
       28
        
       // Patches to simply remove a logger call

     

       30
       29
        
       const stubPatches = [

     

       31
       30
        
         // "sh" is not a valid locale.

     

       32
       32
       -
         [

     

       33
       33
       -
           "is not a valid locale",

     

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

     

       35
       35
       -
         ],

     

       31
       31
       +
         ["is not a valid locale", /(.)\.error\(""\.concat\((.)," is not a valid locale\."\)\)/g],

     

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

     

       37
       37
       -
         [

     

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

     

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

     

       40
       40
       -
         ],

     

       41
       41
       -
         [

     

       42
       42
       -
           '.APP_NATIVE_CRASH,"Storage"',

     

       43
       43
       -
           /console\.log\("AppCrashedFatalReport lastCrash:",.,.\);/

     

       44
       44
       -
         ],

     

       45
       45
       -
         [

     

       46
       46
       -
           '.APP_NATIVE_CRASH,"Storage"',

     

       47
       47
       -
           'console.log("AppCrashedFatalReport: getLastCrash not supported.");'

     

       48
       48
       -
         ],

     

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

     

       34
       34
       +
         ['.APP_NATIVE_CRASH,"Storage"', /console\.log\("AppCrashedFatalReport lastCrash:",.,.\);/],

     

       35
       35
       +
         ['.APP_NATIVE_CRASH,"Storage"', 'console.log("AppCrashedFatalReport: getLastCrash not supported.");'],

     

       49
       36
        
         ['"[NATIVE INFO] ', /new .{1,2}\.Z\(\)\.log\("\[NATIVE INFO] .+?\)\);/],

     

       50
       37
        
         ['"Spellchecker"', /.\.info\("Switching to ".+?"\(unavailable\)"\);?/g],

     

       51
       51
       -
         [

     

       52
       52
       -
           'throw Error("Messages are still loading.");',

     

       53
       53
       -
           /console\.warn\("Unsupported Locale",.\),/

     

       54
       54
       -
         ],

     

       38
       38
       +
         ['throw Error("Messages are still loading.");', /console\.warn\("Unsupported Locale",.\),/],

     

       55
       39
        
         ["}_dispatchWithDevtools(", /.\.totalTime>100&&.\.verbose\(.+?\);/],

     

       56
       56
       -
         [

     

       57
       57
       -
           '"NativeDispatchUtils"',

     

       58
       58
       -
           /null==.&&.\.warn\("Tried getting Dispatch instance before instantiated"\),/

     

       59
       59
       -
         ],

     

       40
       40
       +
         ['"NativeDispatchUtils"', /null==.&&.\.warn\("Tried getting Dispatch instance before instantiated"\),/],

     

       60
       41
        
         ['("DatabaseManager")', /.\.log\("removing database \(user: ".+?\)\),/],

     

       61
       42
        
         [

     

       62
       43
        
           '"Dispatch.dispatch(...): Cannot dispatch in the middle of a dispatch. Action: "',

     

       63
       44
        
           /.\.has\(.\.type\)&&.\.log\(.+?\.type\)\),/

     

       64
       45
        
         ],

     

       65
       65
       -
         [

     

       66
       66
       -
           'console.warn("Window state not initialized"',

     

       67
       67
       -
           /console\.warn\("Window state not initialized",.\),/

     

       68
       68
       -
         ]

     

       46
       46
       +
         ['console.warn("Window state not initialized"', /console\.warn\("Window state not initialized",.\),/]

     

       69
       47
        
       ];

     

       70
       48
        
       

     

       71
       49
        
       const simplePatches = [

     
···

       73
       51
        
         ["suppressDeprecationWarnings=!1", "suppressDeprecationWarnings=!0"],

     

       74
       52
        
       

     

       75
       53
        
         // Zustand related

     

       76
       76
       -
         [

     

       77
       77
       -
           /console\.warn\("\[DEPRECATED\] Please use `subscribeWithSelector` middleware"\)/g,

     

       78
       78
       -
           "/*$&*/"

     

       79
       79
       -
         ],

     

       54
       54
       +
         [/console\.warn\("\[DEPRECATED\] Please use `subscribeWithSelector` middleware"\)/g, "/*$&*/"],

     

       80
       55
        
         ["this.getDebugLogging()", "false"]

     

       81
       56
        
       ] as { [0]: string | RegExp; [1]: string }[];

     

       82
       57

+46 -67

packages/core-extensions/src/rocketship/host/permissions.ts

···

       14
       14
        
         details: Electron.PermissionCheckHandlerHandlerDetails

     

       15
       15
        
       ) => boolean;

     

       16
       16
        
       

     

       17
       17
       -
       moonlightHost.events.on(

     

       18
       18
       -
         "window-created",

     

       19
       19
       -
         (window: BrowserWindow, isMainWindow: boolean) => {

     

       20
       20
       -
           if (!isMainWindow) return;

     

       21
       21
       -
           const windowSession = window.webContents.session;

     

       17
       17
       +
       moonlightHost.events.on("window-created", (window: BrowserWindow, isMainWindow: boolean) => {

     

       18
       18
       +
         if (!isMainWindow) return;

     

       19
       19
       +
         const windowSession = window.webContents.session;

     

       22
       20
        
       

     

       23
       23
       -
           // setPermissionRequestHandler

     

       24
       24
       -
           windowSession.setPermissionRequestHandler(

     

       25
       25
       -
             (webcontents, permission, callback, details) => {

     

       26
       26
       -
               let cbResult = false;

     

       27
       27
       -
               function fakeCallback(result: boolean) {

     

       28
       28
       -
                 cbResult = result;

     

       29
       29
       -
               }

     

       21
       21
       +
         // setPermissionRequestHandler

     

       22
       22
       +
         windowSession.setPermissionRequestHandler((webcontents, permission, callback, details) => {

     

       23
       23
       +
           let cbResult = false;

     

       24
       24
       +
           function fakeCallback(result: boolean) {

     

       25
       25
       +
             cbResult = result;

     

       26
       26
       +
           }

     

       30
       27
        
       

     

       31
       31
       -
               if (caughtPermissionRequestHandler) {

     

       32
       32
       -
                 caughtPermissionRequestHandler(

     

       33
       33
       -
                   webcontents,

     

       34
       34
       -
                   permission,

     

       35
       35
       -
                   fakeCallback,

     

       36
       36
       -
                   details

     

       37
       37
       -
                 );

     

       38
       38
       -
               }

     

       28
       28
       +
           if (caughtPermissionRequestHandler) {

     

       29
       29
       +
             caughtPermissionRequestHandler(webcontents, permission, fakeCallback, details);

     

       30
       30
       +
           }

     

       39
       31
        
       

     

       40
       40
       -
               if (permission === "media" || permission === "display-capture") {

     

       41
       41
       -
                 cbResult = true;

     

       42
       42
       -
               }

     

       32
       32
       +
           if (permission === "media" || permission === "display-capture") {

     

       33
       33
       +
             cbResult = true;

     

       34
       34
       +
           }

     

       43
       35
        
       

     

       44
       44
       -
               callback(cbResult);

     

       45
       45
       -
             }

     

       46
       46
       -
           );

     

       36
       36
       +
           callback(cbResult);

     

       37
       37
       +
         });

     

       47
       38
        
       

     

       48
       48
       -
           let caughtPermissionRequestHandler: PermissionRequestHandler | undefined;

     

       39
       39
       +
         let caughtPermissionRequestHandler: PermissionRequestHandler | undefined;

     

       49
       40
        
       

     

       50
       50
       -
           windowSession.setPermissionRequestHandler =

     

       51
       51
       -
             function catchSetPermissionRequestHandler(

     

       52
       52
       -
               handler: (

     

       53
       53
       -
                 webcontents: Electron.WebContents,

     

       54
       54
       -
                 permission: string,

     

       55
       55
       -
                 callback: (permissionGranted: boolean) => void

     

       56
       56
       -
               ) => void

     

       57
       57
       -
             ) {

     

       58
       58
       -
               caughtPermissionRequestHandler = handler;

     

       59
       59
       -
             };

     

       41
       41
       +
         windowSession.setPermissionRequestHandler = function catchSetPermissionRequestHandler(

     

       42
       42
       +
           handler: (

     

       43
       43
       +
             webcontents: Electron.WebContents,

     

       44
       44
       +
             permission: string,

     

       45
       45
       +
             callback: (permissionGranted: boolean) => void

     

       46
       46
       +
           ) => void

     

       47
       47
       +
         ) {

     

       48
       48
       +
           caughtPermissionRequestHandler = handler;

     

       49
       49
       +
         };

     

       60
       50
        
       

     

       61
       61
       -
           // setPermissionCheckHandler

     

       62
       62
       -
           windowSession.setPermissionCheckHandler(

     

       63
       63
       -
             (webcontents, permission, requestingOrigin, details) => {

     

       64
       64
       -
               return false;

     

       65
       65
       -
             }

     

       66
       66
       -
           );

     

       51
       51
       +
         // setPermissionCheckHandler

     

       52
       52
       +
         windowSession.setPermissionCheckHandler((webcontents, permission, requestingOrigin, details) => {

     

       53
       53
       +
           return false;

     

       54
       54
       +
         });

     

       67
       55
        
       

     

       68
       68
       -
           let caughtPermissionCheckHandler: PermissionCheckHandler | undefined;

     

       56
       56
       +
         let caughtPermissionCheckHandler: PermissionCheckHandler | undefined;

     

       69
       57
        
       

     

       70
       70
       -
           windowSession.setPermissionCheckHandler(

     

       71
       71
       -
             (webcontents, permission, requestingOrigin, details) => {

     

       72
       72
       -
               let result = false;

     

       58
       58
       +
         windowSession.setPermissionCheckHandler((webcontents, permission, requestingOrigin, details) => {

     

       59
       59
       +
           let result = false;

     

       73
       60
        
       

     

       74
       74
       -
               if (caughtPermissionCheckHandler) {

     

       75
       75
       -
                 result = caughtPermissionCheckHandler(

     

       76
       76
       -
                   webcontents,

     

       77
       77
       -
                   permission,

     

       78
       78
       -
                   requestingOrigin,

     

       79
       79
       -
                   details

     

       80
       80
       -
                 );

     

       81
       81
       -
               }

     

       61
       61
       +
           if (caughtPermissionCheckHandler) {

     

       62
       62
       +
             result = caughtPermissionCheckHandler(webcontents, permission, requestingOrigin, details);

     

       63
       63
       +
           }

     

       82
       64
        
       

     

       83
       83
       -
               if (permission === "media" || permission === "display-capture") {

     

       84
       84
       -
                 result = true;

     

       85
       85
       -
               }

     

       65
       65
       +
           if (permission === "media" || permission === "display-capture") {

     

       66
       66
       +
             result = true;

     

       67
       67
       +
           }

     

       86
       68
        
       

     

       87
       87
       -
               return result;

     

       88
       88
       -
             }

     

       89
       89
       -
           );

     

       69
       69
       +
           return result;

     

       70
       70
       +
         });

     

       90
       71
        
       

     

       91
       91
       -
           windowSession.setPermissionCheckHandler =

     

       92
       92
       -
             function catchSetPermissionCheckHandler(handler: PermissionCheckHandler) {

     

       93
       93
       -
               caughtPermissionCheckHandler = handler;

     

       94
       94
       -
             };

     

       95
       95
       -
         }

     

       96
       96
       -
       );

     

       72
       72
       +
         windowSession.setPermissionCheckHandler = function catchSetPermissionCheckHandler(handler: PermissionCheckHandler) {

     

       73
       73
       +
           caughtPermissionCheckHandler = handler;

     

       74
       74
       +
         };

     

       75
       75
       +
       });

+4 -12

packages/core-extensions/src/rocketship/host/types.ts

···

       1
       1
        
       // https://github.com/Vencord/venmic/blob/d737ef33eaae7a73d03ec02673e008cf0243434d/lib/module.d.ts

     

       2
       2
        
       type DefaultProps = "node.name" | "application.name";

     

       3
       3
        
       

     

       4
       4
       -
       type LiteralUnion<LiteralType, BaseType extends string> =

     

       5
       5
       -
         | LiteralType

     

       6
       6
       -
         | (BaseType & Record<never, never>);

     

       4
       4
       +
       type LiteralUnion<LiteralType, BaseType extends string> = LiteralType | (BaseType & Record<never, never>);

     

       7
       5
        
       

     

       8
       8
       -
       type Optional<Type, Key extends keyof Type> = Partial<Pick<Type, Key>> &

     

       9
       9
       -
         Omit<Type, Key>;

     

       6
       6
       +
       type Optional<Type, Key extends keyof Type> = Partial<Pick<Type, Key>> & Omit<Type, Key>;

     

       10
       7
        
       

     

       11
       11
       -
       export type Node<T extends string = never> = Record<

     

       12
       12
       -
         LiteralUnion<T, string>,

     

       13
       13
       -
         string

     

       14
       14
       -
       >;

     

       8
       8
       +
       export type Node<T extends string = never> = Record<LiteralUnion<T, string>, string>;

     

       15
       9
        
       

     

       16
       10
        
       export interface LinkData {

     

       17
       11
        
         include: Node[];

     
···

       29
       23
        
         unlink(): void;

     

       30
       24
        
       

     

       31
       25
        
         list<T extends string = DefaultProps>(props?: T[]): Node<T>[];

     

       32
       32
       -
         link(

     

       33
       33
       -
           data: Optional<LinkData, "exclude"> | Optional<LinkData, "include">

     

       34
       34
       -
         ): boolean;

     

       26
       26
       +
         link(data: Optional<LinkData, "exclude"> | Optional<LinkData, "include">): boolean;

     

       35
       27
        
       }

+23 -31

packages/core-extensions/src/rocketship/host/venmic.ts

···

       7
       7
        
       

     

       8
       8
        
       function getPatchbay() {

     

       9
       9
        
         try {

     

       10
       10
       -
           const venmic = require(

     

       11
       11
       -
             path.join(path.dirname(moonlightHost.asarPath), "..", "venmic.node")

     

       12
       12
       -
           ) as { PatchBay: new () => PatchBay };

     

       10
       10
       +
           const venmic = require(path.join(path.dirname(moonlightHost.asarPath), "..", "venmic.node")) as {

     

       11
       11
       +
             PatchBay: new () => PatchBay;

     

       12
       12
       +
           };

     

       13
       13
        
           const patchbay = new venmic.PatchBay();

     

       14
       14
        
           return patchbay;

     

       15
       15
        
         } catch (error) {

     
···

       35
       35
        
       

     

       36
       36
        
           patchbay.unlink();

     

       37
       37
        
           return patchbay.link({

     

       38
       38
       -
             exclude: [

     

       39
       39
       -
               { "application.process.id": pid },

     

       40
       40
       -
               { "media.class": "Stream/Input/Audio" }

     

       41
       41
       -
             ],

     

       38
       38
       +
             exclude: [{ "application.process.id": pid }, { "media.class": "Stream/Input/Audio" }],

     

       42
       39
        
             ignore_devices: true,

     

       43
       40
        
             only_speakers: true,

     

       44
       41
        
             only_default_speakers: true

     
···

       49
       46
        
         }

     

       50
       47
        
       }

     

       51
       48
        
       

     

       52
       52
       -
       moonlightHost.events.on(

     

       53
       53
       -
         "window-created",

     

       54
       54
       -
         (window: BrowserWindow, isMainWindow: boolean) => {

     

       55
       55
       -
           if (!isMainWindow) return;

     

       56
       56
       -
           const windowSession = window.webContents.session;

     

       49
       49
       +
       moonlightHost.events.on("window-created", (window: BrowserWindow, isMainWindow: boolean) => {

     

       50
       50
       +
         if (!isMainWindow) return;

     

       51
       51
       +
         const windowSession = window.webContents.session;

     

       57
       52
        
       

     

       58
       58
       -
           // @ts-expect-error these types ancient

     

       59
       59
       -
           windowSession.setDisplayMediaRequestHandler(

     

       60
       60
       -
             (request: any, callback: any) => {

     

       61
       61
       -
               const linked = linkVenmic();

     

       62
       62
       -
               desktopCapturer

     

       63
       63
       -
                 .getSources({ types: ["screen", "window"] })

     

       64
       64
       -
                 .then((sources) => {

     

       65
       65
       -
                   //logger.debug("desktopCapturer.getSources", sources);

     

       66
       66
       -
                   logger.debug("Linked to venmic:", linked);

     

       53
       53
       +
         // @ts-expect-error these types ancient

     

       54
       54
       +
         windowSession.setDisplayMediaRequestHandler(

     

       55
       55
       +
           (request: any, callback: any) => {

     

       56
       56
       +
             const linked = linkVenmic();

     

       57
       57
       +
             desktopCapturer.getSources({ types: ["screen", "window"] }).then((sources) => {

     

       58
       58
       +
               //logger.debug("desktopCapturer.getSources", sources);

     

       59
       59
       +
               logger.debug("Linked to venmic:", linked);

     

       67
       60
        
       

     

       68
       68
       -
                   callback({

     

       69
       69
       -
                     video: sources[0],

     

       70
       70
       -
                     audio: "loopback"

     

       71
       71
       -
                   });

     

       72
       72
       -
                 });

     

       73
       73
       -
             },

     

       74
       74
       -
             { useSystemPicker: true }

     

       75
       75
       -
           );

     

       76
       76
       -
         }

     

       77
       77
       -
       );

     

       61
       61
       +
               callback({

     

       62
       62
       +
                 video: sources[0],

     

       63
       63
       +
                 audio: "loopback"

     

       64
       64
       +
               });

     

       65
       65
       +
             });

     

       66
       66
       +
           },

     

       67
       67
       +
           { useSystemPicker: true }

     

       68
       68
       +
         );

     

       69
       69
       +
       });

+5 -11

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

···

       9
       9
        
           logger.debug("Devices:", devices);

     

       10
       10
        
       

     

       11
       11
        
           // This isn't vencord :(

     

       12
       12
       -
           const id = devices.find((device) => device.label === "vencord-screen-share")

     

       13
       13
       -
             ?.deviceId;

     

       12
       12
       +
           const id = devices.find((device) => device.label === "vencord-screen-share")?.deviceId;

     

       14
       13
        
           if (!id) return null;

     

       15
       14
        
           logger.debug("Got venmic device ID:", id);

     

       16
       15
        
       

     
···

       32
       31
        
         }

     

       33
       32
        
       }

     

       34
       33
        
       

     

       35
       35
       -
       navigator.mediaDevices.getDisplayMedia = async function getDisplayMediaRedirect(

     

       36
       36
       -
         options

     

       37
       37
       -
       ) {

     

       34
       34
       +
       navigator.mediaDevices.getDisplayMedia = async function getDisplayMediaRedirect(options) {

     

       38
       35
        
         const orig = await getDisplayMediaOrig.call(this, options);

     

       39
       36
        
       

     

       40
       37
        
         const venmic = await getVenmicStream();

     
···

       114
       111
        
           replace: [

     

       115
       112
        
             // Prevent loading of krisp native module by stubbing out desktop checks

     

       116
       113
        
             {

     

       117
       117
       -
               match:

     

       118
       118
       -
                 /\(\(0,.\.isWindows\)\(\)\|\|\(0,.\.isLinux\)\(\)\|\|.+?&&!__OVERLAY__/,

     

       114
       114
       +
               match: /\(\(0,.\.isWindows\)\(\)\|\|\(0,.\.isLinux\)\(\)\|\|.+?&&!__OVERLAY__/,

     

       119
       115
        
               replacement: (orig, macosPlatformCheck) => `false&&!__OVERLAY__`

     

       120
       116
        
             },

     

       121
       117
        
             // Enable loading of web krisp equivelant by replacing isWeb with true

     

       122
       118
        
             {

     

       123
       123
       -
               match:

     

       124
       124
       -
                 /\(0,.\.isWeb\)\(\)&&(.{1,2}\.supports\(.{1,2}\..{1,2}.NOISE_CANCELLATION)/,

     

       125
       125
       -
               replacement: (orig, supportsNoiseCancellation) =>

     

       126
       126
       -
                 `true&&${supportsNoiseCancellation}`

     

       119
       119
       +
               match: /\(0,.\.isWeb\)\(\)&&(.{1,2}\.supports\(.{1,2}\..{1,2}.NOISE_CANCELLATION)/,

     

       120
       120
       +
               replacement: (orig, supportsNoiseCancellation) => `true&&${supportsNoiseCancellation}`

     

       127
       121
        
             }

     

       128
       122
        
           ]

     

       129
       123
        
         }

+2 -4

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

···

       6
       6
        
           find: '"useGenerateUserSettingsSections"',

     

       7
       7
        
           replace: {

     

       8
       8
        
             match: /(?<=\.push\(.+?\)}\)\)}\),)(.+?)}/,

     

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

     

       10
       10
       -
               `require("settings_settings").Settings._mutateSections(${sections})}`

     

       9
       9
       +
             replacement: (_, sections: string) => `require("settings_settings").Settings._mutateSections(${sections})}`

     

       11
       10
        
           }

     

       12
       11
        
         },

     

       13
       12
        
         {

     
···

       17
       16
        
             replacement: (orig, sections, section) =>

     

       18
       17
        
               `${orig.replace(

     

       19
       18
        
                 /Object\.values\(.\..+?\)/,

     

       20
       20
       -
                 (orig) =>

     

       21
       21
       -
                   `[...require("settings_settings").Settings.sectionNames,...${orig}]`

     

       19
       19
       +
                 (orig) => `[...require("settings_settings").Settings.sectionNames,...${orig}]`

     

       22
       20
        
               )}??${sections}.find(x=>x.section==${section})?._moonlight_submenu?.()`

     

       23
       21
        
           }

     

       24
       22
        
         }

+3 -11

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

···

       1
       1
       -
       import {

     

       2
       2
       -
         SettingsSection,

     

       3
       3
       -
         Settings as SettingsType

     

       4
       4
       -
       } from "@moonlight-mod/types/coreExtensions/settings";

     

       1
       1
       +
       import { SettingsSection, Settings as SettingsType } from "@moonlight-mod/types/coreExtensions/settings";

     

       5
       2
        
       

     

       6
       3
        
       export const Settings: SettingsType = {

     

       7
       4
        
         ourSections: [],

     
···

       24
       21
        
         },

     

       25
       22
        
         addSectionMenuItems(section, ...newItems) {

     

       26
       23
        
           const data = Settings.ourSections.find((x) => x.section === section);

     

       27
       27
       -
           if (!data || !("element" in data))

     

       28
       28
       -
             throw new Error(`Could not find section "${section}"`);

     

       24
       24
       +
           if (!data || !("element" in data)) throw new Error(`Could not find section "${section}"`);

     

       29
       25
        
           (Settings.sectionMenuItems[section] ??= []).push(...newItems);

     

       30
       26
        
           data._moonlight_submenu ??= () => Settings.sectionMenuItems[section];

     

       31
       27
        
         },

     
···

       47
       43
        
       

     

       48
       44
        
         _mutateSections: (sections) => {

     

       49
       45
        
           for (const section of Settings.ourSections) {

     

       50
       50
       -
             sections.splice(

     

       51
       51
       -
               section.pos < 0 ? sections.length + section.pos : section.pos,

     

       52
       52
       -
               0,

     

       53
       53
       -
               section

     

       54
       54
       -
             );

     

       46
       46
       +
             sections.splice(section.pos < 0 ? sections.length + section.pos : section.pos, 0, section);

     

       55
       47
        
           }

     

       56
       48
        
       

     

       57
       49
        
           return sections;

+13 -46

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

···

       1
       1
       -
       import {

     

       2
       2
       -
         WebpackModule,

     

       3
       3
       -
         WebpackModuleFunc,

     

       4
       4
       -
         WebpackRequireType

     

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

     

       1
       1
       +
       import { WebpackModule, WebpackModuleFunc, WebpackRequireType } from "@moonlight-mod/types";

     

       6
       2
        
       import { Spacepack } from "@moonlight-mod/types/coreExtensions/spacepack";

     

       7
       3
        
       

     

       8
       4
        
       const webpackRequire = require as unknown as WebpackRequireType;

     
···

       40
       36
        
             "module",

     

       41
       37
        
             "exports",

     

       42
       38
        
             "require",

     

       43
       43
       -
             `(${funcStr}).apply(this, arguments)\n` +

     

       44
       44
       -
               `//# sourceURL=Webpack-Module-${module}`

     

       39
       39
       +
             `(${funcStr}).apply(this, arguments)\n` + `//# sourceURL=Webpack-Module-${module}`

     

       45
       40
        
           ) as WebpackModuleFunc;

     

       46
       41
        
         },

     

       47
       42
        
       

     
···

       50
       45
        
             .filter(

     

       51
       46
        
               ([id, mod]) =>

     

       52
       47
        
                 !args.some(

     

       53
       53
       -
                   (item) =>

     

       54
       54
       -
                     !(item instanceof RegExp

     

       55
       55
       -
                       ? item.test(mod.toString())

     

       56
       56
       -
                       : mod.toString().indexOf(item) !== -1)

     

       48
       48
       +
                   (item) => !(item instanceof RegExp ? item.test(mod.toString()) : mod.toString().indexOf(item) !== -1)

     

       57
       49
        
                 )

     

       58
       50
        
             )

     

       59
       51
        
             .map(([id]) => {

     
···

       84
       76
        
                     !(

     

       85
       77
        
                       exports !== undefined &&

     

       86
       78
        
                       exports !== window &&

     

       87
       87
       -
                       (exports?.[item] ||

     

       88
       88
       -
                         exports?.default?.[item] ||

     

       89
       89
       -
                         exports?.Z?.[item] ||

     

       90
       90
       -
                         exports?.ZP?.[item])

     

       79
       79
       +
                       (exports?.[item] || exports?.default?.[item] || exports?.Z?.[item] || exports?.ZP?.[item])

     

       91
       80
        
                     )

     

       92
       81
        
                 )

     

       93
       82
        
             )

     
···

       133
       122
        
           return null;

     

       134
       123
        
         },

     

       135
       124
        
       

     

       136
       136
       -
         findObjectFromKeyValuePair: (

     

       137
       137
       -
           exports: Record<string, any>,

     

       138
       138
       -
           key: string,

     

       139
       139
       -
           value: any

     

       140
       140
       -
         ) => {

     

       125
       125
       +
         findObjectFromKeyValuePair: (exports: Record<string, any>, key: string, value: any) => {

     

       141
       126
        
           for (const exportKey in exports) {

     

       142
       127
        
             const obj = exports[exportKey];

     

       143
       128
        
             // eslint-disable-next-line eqeqeq

     
···

       148
       133
        
           return null;

     

       149
       134
        
         },

     

       150
       135
        
       

     

       151
       151
       -
         findFunctionByStrings: (

     

       152
       152
       -
           exports: Record<string, any>,

     

       153
       153
       -
           ...strings: (string | RegExp)[]

     

       154
       154
       -
         ) => {

     

       136
       136
       +
         findFunctionByStrings: (exports: Record<string, any>, ...strings: (string | RegExp)[]) => {

     

       155
       137
        
           return (

     

       156
       138
        
             Object.entries(exports).filter(

     

       157
       139
        
               ([index, func]) =>

     

       158
       140
        
                 typeof func === "function" &&

     

       159
       141
        
                 !strings.some(

     

       160
       160
       -
                   (query) =>

     

       161
       161
       -
                     !(query instanceof RegExp

     

       162
       162
       -
                       ? func.toString().match(query)

     

       163
       163
       -
                       : func.toString().includes(query))

     

       142
       142
       +
                   (query) => !(query instanceof RegExp ? func.toString().match(query) : func.toString().includes(query))

     

       164
       143
        
                 )

     

       165
       144
        
             )?.[0]?.[1] ?? null

     

       166
       145
        
           );

     

       167
       146
        
         },

     

       168
       147
        
       

     

       169
       169
       -
         lazyLoad: (

     

       170
       170
       -
           find: string | RegExp | (string | RegExp)[],

     

       171
       171
       -
           chunk: RegExp,

     

       172
       172
       -
           module: RegExp

     

       173
       173
       -
         ) => {

     

       174
       174
       -
           const mod = Array.isArray(find)

     

       175
       175
       -
             ? spacepack.findByCode(...find)

     

       176
       176
       -
             : spacepack.findByCode(find);

     

       148
       148
       +
         lazyLoad: (find: string | RegExp | (string | RegExp)[], chunk: RegExp, module: RegExp) => {

     

       149
       149
       +
           const mod = Array.isArray(find) ? spacepack.findByCode(...find) : spacepack.findByCode(find);

     

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

     

       178
       151
        
       

     

       179
       152
        
           const findId = mod[0].id;

     
···

       184
       157
        
             chunkIds = [...findCode.matchAll(chunk)].map(([, id]) => id);

     

       185
       158
        
           } else {

     

       186
       159
        
             const match = findCode.match(chunk);

     

       187
       187
       -
             if (match)

     

       188
       188
       -
               chunkIds = [...match[0].matchAll(/"(\d+)"/g)].map(([, id]) => id);

     

       160
       160
       +
             if (match) chunkIds = [...match[0].matchAll(/"(\d+)"/g)].map(([, id]) => id);

     

       189
       161
        
           }

     

       190
       162
        
       

     

       191
       191
       -
           if (!chunkIds || chunkIds.length === 0)

     

       192
       192
       -
             return Promise.reject("Chunk ID match failed");

     

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

     

       193
       164
        
       

     

       194
       165
        
           const moduleId = findCode.match(module)?.[1];

     

       195
       166
        
           if (!moduleId) return Promise.reject("Module ID match failed");

     

       196
       167
        
       

     

       197
       197
       -
           return Promise.all(chunkIds.map((c) => webpackRequire.e(c))).then(() =>

     

       198
       198
       -
             webpackRequire(moduleId)

     

       199
       199
       -
           );

     

       168
       168
       +
           return Promise.all(chunkIds.map((c) => webpackRequire.e(c))).then(() => webpackRequire(moduleId));

     

       200
       169
        
         },

     

       201
       170
        
       

     

       202
       171
        
         filterReal: (modules: WebpackModule[]) => {

     
···

       204
       173
        
         }

     

       205
       174
        
       };

     

       206
       175
        
       

     

       207
       207
       -
       if (

     

       208
       208
       -
         moonlight.getConfigOption<boolean>("spacepack", "addToGlobalScope") === true

     

       209
       209
       -
       ) {

     

       176
       176
       +
       if (moonlight.getConfigOption<boolean>("spacepack", "addToGlobalScope") === true) {

     

       210
       177
        
         window.spacepack = spacepack;

     

       211
       178
        
       }

     

       212
       179

+2 -7

packages/core/src/config.ts

···

       18
       18
        
       export async function writeConfig(config: Config) {

     

       19
       19
        
         try {

     

       20
       20
        
           const configPath = await getConfigPath();

     

       21
       21
       -
           await moonlightFS.writeFileString(

     

       22
       22
       -
             configPath,

     

       23
       23
       -
             JSON.stringify(config, null, 2)

     

       24
       24
       -
           );

     

       21
       21
       +
           await moonlightFS.writeFileString(configPath, JSON.stringify(config, null, 2));

     

       25
       22
        
         } catch (e) {

     

       26
       23
        
           logger.error("Failed to write config", e);

     

       27
       24
        
         }

     
···

       38
       35
        
           return defaultConfig;

     

       39
       36
        
         } else {

     

       40
       37
        
           try {

     

       41
       41
       -
             let config: Config = JSON.parse(

     

       42
       42
       -
               await moonlightFS.readFileString(configPath)

     

       43
       43
       -
             );

     

       38
       38
       +
             let config: Config = JSON.parse(await moonlightFS.readFileString(configPath));

     

       44
       39
        
             // Assign the default values if they don't exist (newly added)

     

       45
       40
        
             config = { ...defaultConfig, ...config };

     

       46
       41
        
             await writeConfig(config);

+15 -59

packages/core/src/extension.ts

···

       1
       1
       -
       import {

     

       2
       2
       -
         ExtensionManifest,

     

       3
       3
       -
         DetectedExtension,

     

       4
       4
       -
         ExtensionLoadSource,

     

       5
       5
       -
         constants

     

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

     

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

     

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

     

       8
       3
        
       import { getCoreExtensionsPath, getExtensionsPath } from "./util/data";

     

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

     
···

       29
       24
        
         return ret;

     

       30
       25
        
       }

     

       31
       26
        
       

     

       32
       32
       -
       async function loadDetectedExtensions(

     

       33
       33
       -
         dir: string,

     

       34
       34
       -
         type: ExtensionLoadSource

     

       35
       35
       -
       ): Promise<DetectedExtension[]> {

     

       27
       27
       +
       async function loadDetectedExtensions(dir: string, type: ExtensionLoadSource): Promise<DetectedExtension[]> {

     

       36
       28
        
         const ret: DetectedExtension[] = [];

     

       37
       29
        
       

     

       38
       30
        
         const manifests = await findManifests(dir);

     
···

       41
       33
        
             if (!(await moonlightFS.exists(manifestPath))) continue;

     

       42
       34
        
             const dir = moonlightFS.dirname(manifestPath);

     

       43
       35
        
       

     

       44
       44
       -
             const manifest: ExtensionManifest = JSON.parse(

     

       45
       45
       -
               await moonlightFS.readFileString(manifestPath)

     

       46
       46
       -
             );

     

       36
       36
       +
             const manifest: ExtensionManifest = JSON.parse(await moonlightFS.readFileString(manifestPath));

     

       47
       37
        
       

     

       48
       38
        
             const webPath = moonlightFS.join(dir, "index.js");

     

       49
       39
        
             const nodePath = moonlightFS.join(dir, "node.js");

     

       50
       40
        
             const hostPath = moonlightFS.join(dir, "host.js");

     

       51
       41
        
       

     

       52
       42
        
             // if none exist (empty manifest) don't give a shit

     

       53
       53
       -
             if (

     

       54
       54
       -
               !moonlightFS.exists(webPath) &&

     

       55
       55
       -
               !moonlightFS.exists(nodePath) &&

     

       56
       56
       -
               !moonlightFS.exists(hostPath)

     

       57
       57
       -
             ) {

     

       43
       43
       +
             if (!moonlightFS.exists(webPath) && !moonlightFS.exists(nodePath) && !moonlightFS.exists(hostPath)) {

     

       58
       44
        
               continue;

     

       59
       45
        
             }

     

       60
       46
        
       

     

       61
       61
       -
             const web = (await moonlightFS.exists(webPath))

     

       62
       62
       -
               ? await moonlightFS.readFileString(webPath)

     

       63
       63
       -
               : undefined;

     

       47
       47
       +
             const web = (await moonlightFS.exists(webPath)) ? await moonlightFS.readFileString(webPath) : undefined;

     

       64
       48
        
       

     

       65
       49
        
             let url: string | undefined = undefined;

     

       66
       50
        
             const urlPath = moonlightFS.join(dir, constants.repoUrlFile);

     

       67
       67
       -
             if (

     

       68
       68
       -
               type === ExtensionLoadSource.Normal &&

     

       69
       69
       -
               (await moonlightFS.exists(urlPath))

     

       70
       70
       -
             ) {

     

       51
       51
       +
             if (type === ExtensionLoadSource.Normal && (await moonlightFS.exists(urlPath))) {

     

       71
       52
        
               url = await moonlightFS.readFileString(urlPath);

     

       72
       53
        
             }

     

       73
       54
        
       

     
···

       78
       59
        
       

     

       79
       60
        
               for (const wpModuleFile of wpModulesFile) {

     

       80
       61
        
                 if (wpModuleFile.endsWith(".js")) {

     

       81
       81
       -
                   wpModules[wpModuleFile.replace(".js", "")] =

     

       82
       82
       -
                     await moonlightFS.readFileString(

     

       83
       83
       -
                       moonlightFS.join(wpModulesPath, wpModuleFile)

     

       84
       84
       -
                     );

     

       62
       62
       +
                   wpModules[wpModuleFile.replace(".js", "")] = await moonlightFS.readFileString(

     

       63
       63
       +
                     moonlightFS.join(wpModulesPath, wpModuleFile)

     

       64
       64
       +
                   );

     

       85
       65
        
                 }

     

       86
       66
        
               }

     

       87
       67
        
             }

     
···

       113
       93
        
         const config = await readConfig();

     

       114
       94
        
         const res = [];

     

       115
       95
        
       

     

       116
       116
       -
         res.push(

     

       117
       117
       -
           ...(await loadDetectedExtensions(

     

       118
       118
       -
             getCoreExtensionsPath(),

     

       119
       119
       -
             ExtensionLoadSource.Core

     

       120
       120
       -
           ))

     

       121
       121
       -
         );

     

       96
       96
       +
         res.push(...(await loadDetectedExtensions(getCoreExtensionsPath(), ExtensionLoadSource.Core)));

     

       122
       97
        
       

     

       123
       123
       -
         res.push(

     

       124
       124
       -
           ...(await loadDetectedExtensions(

     

       125
       125
       -
             await getExtensionsPath(),

     

       126
       126
       -
             ExtensionLoadSource.Normal

     

       127
       127
       -
           ))

     

       128
       128
       -
         );

     

       98
       98
       +
         res.push(...(await loadDetectedExtensions(await getExtensionsPath(), ExtensionLoadSource.Normal)));

     

       129
       99
        
       

     

       130
       100
        
         for (const devSearchPath of config.devSearchPaths ?? []) {

     

       131
       131
       -
           res.push(

     

       132
       132
       -
             ...(await loadDetectedExtensions(

     

       133
       133
       -
               devSearchPath,

     

       134
       134
       -
               ExtensionLoadSource.Developer

     

       135
       135
       -
             ))

     

       136
       136
       -
           );

     

       101
       101
       +
           res.push(...(await loadDetectedExtensions(devSearchPath, ExtensionLoadSource.Developer)));

     

       137
       102
        
         }

     

       138
       103
        
       

     

       139
       104
        
         return res;

     
···

       146
       111
        
           // @ts-expect-error shut up

     

       147
       112
        
           _moonlight_coreExtensionsStr

     

       148
       113
        
         );

     

       149
       149
       -
         const coreExtensions = Array.from(

     

       150
       150
       -
           new Set(Object.keys(coreExtensionsFs).map((x) => x.split("/")[0]))

     

       151
       151
       -
         );

     

       114
       114
       +
         const coreExtensions = Array.from(new Set(Object.keys(coreExtensionsFs).map((x) => x.split("/")[0])));

     

       152
       115
        
       

     

       153
       116
        
         for (const ext of coreExtensions) {

     

       154
       117
        
           if (!coreExtensionsFs[`${ext}/index.js`]) continue;

     
···

       159
       122
        
           const wpModulesPath = `${ext}/webpackModules`;

     

       160
       123
        
           for (const wpModuleFile of Object.keys(coreExtensionsFs)) {

     

       161
       124
        
             if (wpModuleFile.startsWith(wpModulesPath)) {

     

       162
       162
       -
               wpModules[

     

       163
       163
       -
                 wpModuleFile.replace(wpModulesPath + "/", "").replace(".js", "")

     

       164
       164
       -
               ] = coreExtensionsFs[wpModuleFile];

     

       125
       125
       +
               wpModules[wpModuleFile.replace(wpModulesPath + "/", "").replace(".js", "")] = coreExtensionsFs[wpModuleFile];

     

       165
       126
        
             }

     

       166
       127
        
           }

     

       167
       128
        
       

     
···

       179
       140
        
         }

     

       180
       141
        
       

     

       181
       142
        
         if (await moonlightFS.exists("/extensions")) {

     

       182
       182
       -
           ret.push(

     

       183
       183
       -
             ...(await loadDetectedExtensions(

     

       184
       184
       -
               "/extensions",

     

       185
       185
       -
               ExtensionLoadSource.Normal

     

       186
       186
       -
             ))

     

       187
       187
       -
           );

     

       143
       143
       +
           ret.push(...(await loadDetectedExtensions("/extensions", ExtensionLoadSource.Normal)));

     

       188
       144
        
         }

     

       189
       145
        
       

     

       190
       146
        
         return ret;

+8 -25

packages/core/src/extension/loader.ts

···

       73
       73
        
           }

     

       74
       74
        
       

     

       75
       75
        
           if (exports.styles != null) {

     

       76
       76
       -
             registerStyles(

     

       77
       77
       -
               exports.styles.map((style, i) => `/* ${ext.id}#${i} */ ${style}`)

     

       78
       78
       -
             );

     

       76
       76
       +
             registerStyles(exports.styles.map((style, i) => `/* ${ext.id}#${i} */ ${style}`));

     

       79
       77
        
           }

     

       80
       78
        
         }

     

       81
       79
        
       }

     
···

       113
       111
        
         InvalidEnvironment

     

       114
       112
        
       }

     

       115
       113
        
       

     

       116
       116
       -
       export function checkExtensionCompat(

     

       117
       117
       -
         manifest: ExtensionManifest

     

       118
       118
       -
       ): ExtensionCompat {

     

       114
       114
       +
       export function checkExtensionCompat(manifest: ExtensionManifest): ExtensionCompat {

     

       119
       115
        
         let environment;

     

       120
       116
        
         webTarget: {

     

       121
       117
        
           environment = ExtensionEnvironment.Web;

     
···

       124
       120
        
           environment = ExtensionEnvironment.Desktop;

     

       125
       121
        
         }

     

       126
       122
        
       

     

       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
       -
         )

     

       123
       123
       +
         if (manifest.apiLevel !== constants.apiLevel) return ExtensionCompat.InvalidApiLevel;

     

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

     

       133
       125
        
           return ExtensionCompat.InvalidEnvironment;

     

       134
       126
        
         return ExtensionCompat.Compatible;

     

       135
       127
        
       }

     
···

       148
       140
        
         extensions fires an event on completion, which allows us to await the loading

     

       149
       141
        
         of another extension, resolving dependencies & load order effectively.

     

       150
       142
        
       */

     

       151
       151
       -
       export async function loadExtensions(

     

       152
       152
       -
         exts: DetectedExtension[]

     

       153
       153
       -
       ): Promise<ProcessedExtensions> {

     

       154
       154
       -
         exts = exts.filter(

     

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

     

       156
       156
       -
         );

     

       143
       143
       +
       export async function loadExtensions(exts: DetectedExtension[]): Promise<ProcessedExtensions> {

     

       144
       144
       +
         exts = exts.filter((ext) => checkExtensionCompat(ext.manifest) === ExtensionCompat.Compatible);

     

       157
       145
        
       

     

       158
       146
        
         const config = await readConfig();

     

       159
       147
        
         const items = exts

     
···

       193
       181
        
         };

     

       194
       182
        
       }

     

       195
       183
        
       

     

       196
       196
       -
       export async function loadProcessedExtensions({

     

       197
       197
       -
         extensions,

     

       198
       198
       -
         dependencyGraph

     

       199
       199
       -
       }: ProcessedExtensions) {

     

       184
       184
       +
       export async function loadProcessedExtensions({ extensions, dependencyGraph }: ProcessedExtensions) {

     

       200
       185
        
         const eventEmitter = createEventEmitter<EventType, EventPayloads>();

     

       201
       186
        
         const finished: Set<string> = new Set();

     

       202
       187
        
       

     
···

       229
       214
        
           );

     

       230
       215
        
       

     

       231
       216
        
           if (waitPromises.length > 0) {

     

       232
       232
       -
             logger.debug(

     

       233
       233
       -
               `Waiting on ${waitPromises.length} dependencies for "${ext.id}"`

     

       234
       234
       -
             );

     

       217
       217
       +
             logger.debug(`Waiting on ${waitPromises.length} dependencies for "${ext.id}"`);

     

       235
       218
        
             await Promise.all(waitPromises);

     

       236
       219
        
           }

     

       237
       220

+21 -59

packages/core/src/patch.ts

···

       21
       21
        
       let webpackModules: Set<IdentifiedWebpackModule> = new Set();

     

       22
       22
        
       let webpackRequire: WebpackRequireType | null = null;

     

       23
       23
        
       

     

       24
       24
       -
       const moduleLoadSubscriptions: Map<string, ((moduleId: string) => void)[]> =

     

       25
       25
       -
         new Map();

     

       24
       24
       +
       const moduleLoadSubscriptions: Map<string, ((moduleId: string) => void)[]> = new Map();

     

       26
       25
        
       

     

       27
       26
        
       export function registerPatch(patch: IdentifiedPatch) {

     

       28
       27
        
         patches.push(patch);

     
···

       36
       35
        
         }

     

       37
       36
        
       }

     

       38
       37
        
       

     

       39
       39
       -
       export function onModuleLoad(

     

       40
       40
       -
         module: string | string[],

     

       41
       41
       -
         callback: (moduleId: string) => void

     

       42
       42
       -
       ): void {

     

       38
       38
       +
       export function onModuleLoad(module: string | string[], callback: (moduleId: string) => void): void {

     

       43
       39
        
         let moduleIds = module;

     

       44
       40
        
       

     

       45
       41
        
         if (typeof module === "string") {

     
···

       83
       79
        
             `//# sourceURL=Webpack-Module-${id}`;

     

       84
       80
        
       

     

       85
       81
        
           try {

     

       86
       86
       -
             const func = new Function(

     

       87
       87
       -
               "module",

     

       88
       88
       -
               "exports",

     

       89
       89
       -
               "require",

     

       90
       90
       -
               wrapped

     

       91
       91
       -
             ) as WebpackModuleFunc;

     

       82
       82
       +
             const func = new Function("module", "exports", "require", wrapped) as WebpackModuleFunc;

     

       92
       83
        
             entry[id] = func;

     

       93
       84
        
             entry[id].__moonlight = true;

     

       94
       85
        
             return true;

     
···

       124
       115
        
       

     

       125
       116
        
             // indexOf is faster than includes by 0.25% lmao

     

       126
       117
        
             const match =

     

       127
       127
       -
               typeof patch.find === "string"

     

       128
       128
       -
                 ? moduleString.indexOf(patch.find) !== -1

     

       129
       129
       -
                 : patch.find.test(moduleString);

     

       118
       118
       +
               typeof patch.find === "string" ? moduleString.indexOf(patch.find) !== -1 : patch.find.test(moduleString);

     

       130
       119
        
       

     

       131
       120
        
             // Global regexes apply to all modules

     

       132
       132
       -
             const shouldRemove =

     

       133
       133
       -
               typeof patch.find === "string" ? true : !patch.find.global;

     

       121
       121
       +
             const shouldRemove = typeof patch.find === "string" ? true : !patch.find.global;

     

       134
       122
        
       

     

       135
       123
        
             if (match) {

     

       136
       124
        
               moonlight.unpatched.delete(patch);

     
···

       138
       126
        
               // We ensured all arrays get turned into normal PatchReplace objects on register

     

       139
       127
        
               const replace = patch.replace as PatchReplace;

     

       140
       128
        
       

     

       141
       141
       -
               if (

     

       142
       142
       -
                 replace.type === undefined ||

     

       143
       143
       -
                 replace.type === PatchReplaceType.Normal

     

       144
       144
       -
               ) {

     

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

     

       145
       130
        
                 // Add support for \i to match rspack's minified names

     

       146
       131
        
                 if (typeof replace.match !== "string") {

     

       147
       147
       -
                   replace.match = new RegExp(

     

       148
       148
       -
                     replace.match.source.replace(/\\i/g, "[A-Za-z_$][\\w$]*"),

     

       149
       149
       -
                     replace.match.flags

     

       150
       150
       -
                   );

     

       132
       132
       +
                   replace.match = new RegExp(replace.match.source.replace(/\\i/g, "[A-Za-z_$][\\w$]*"), replace.match.flags);

     

       151
       133
        
                 }

     

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

     

       153
       135
        
                 // Verbose, but it works

     
···

       171
       153
        
                 const newModule = replace.replacement(moduleString);

     

       172
       154
        
                 entry[id] = newModule;

     

       173
       155
        
                 entry[id].__moonlight = true;

     

       174
       174
       -
                 moduleString =

     

       175
       175
       -
                   newModule.toString().replace(/\n/g, "") +

     

       176
       176
       -
                   `//# sourceURL=Webpack-Module-${id}`;

     

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

     

       177
       157
        
               }

     

       178
       158
        
       

     

       179
       159
        
               if (shouldRemove) {

     
···

       198
       178
        
           }

     

       199
       179
        
       

     

       200
       180
        
           if (moonlightNode.config.patchAll === true) {

     

       201
       201
       -
             if (

     

       202
       202
       -
               (typeof id !== "string" || !id.includes("_")) &&

     

       203
       203
       -
               !entry[id].__moonlight

     

       204
       204
       -
             ) {

     

       205
       205
       -
               const wrapped =

     

       206
       206
       -
                 `(${moduleCache[id]}).apply(this, arguments)\n` +

     

       207
       207
       -
                 `//# sourceURL=Webpack-Module-${id}`;

     

       208
       208
       -
               entry[id] = new Function(

     

       209
       209
       -
                 "module",

     

       210
       210
       -
                 "exports",

     

       211
       211
       -
                 "require",

     

       212
       212
       -
                 wrapped

     

       213
       213
       -
               ) as WebpackModuleFunc;

     

       181
       181
       +
             if ((typeof id !== "string" || !id.includes("_")) && !entry[id].__moonlight) {

     

       182
       182
       +
               const wrapped = `(${moduleCache[id]}).apply(this, arguments)\n` + `//# sourceURL=Webpack-Module-${id}`;

     

       183
       183
       +
               entry[id] = new Function("module", "exports", "require", wrapped) as WebpackModuleFunc;

     

       214
       184
        
               entry[id].__moonlight = true;

     

       215
       185
        
             }

     

       216
       186
        
           }

     
···

       246
       216
        
       function handleModuleDependencies() {

     

       247
       217
        
         const modules = Array.from(webpackModules.values());

     

       248
       218
        
       

     

       249
       249
       -
         const dependencies: Dependency<string, IdentifiedWebpackModule>[] =

     

       250
       250
       -
           modules.map((wp) => {

     

       251
       251
       -
             return {

     

       252
       252
       -
               id: depToString(wp),

     

       253
       253
       -
               data: wp

     

       254
       254
       -
             };

     

       255
       255
       -
           });

     

       219
       219
       +
         const dependencies: Dependency<string, IdentifiedWebpackModule>[] = modules.map((wp) => {

     

       220
       220
       +
           return {

     

       221
       221
       +
             id: depToString(wp),

     

       222
       222
       +
             data: wp

     

       223
       223
       +
           };

     

       224
       224
       +
         });

     

       256
       225
        
       

     

       257
       226
        
         const [sorted, _] = calculateDependencies(dependencies, {

     

       258
       227
        
           fetchDep: (id) => {

     
···

       263
       232
        
             const deps = item.data?.dependencies ?? [];

     

       264
       233
        
             return (

     

       265
       234
        
               deps.filter(

     

       266
       266
       -
                 (dep) =>

     

       267
       267
       -
                   !(dep instanceof RegExp || typeof dep === "string") &&

     

       268
       268
       -
                   dep.ext != null

     

       235
       235
       +
                 (dep) => !(dep instanceof RegExp || typeof dep === "string") && dep.ext != null

     

       269
       236
        
               ) as ExplicitExtensionDependency[]

     

       270
       237
        
             ).map(depToString);

     

       271
       238
        
           }

     
···

       297
       264
        
                     if (dep.test(modStr)) deps.delete(dep);

     

       298
       265
        
                   } else if (

     

       299
       266
        
                     dep.ext != null

     

       300
       300
       -
                       ? injectedWpModules.find(

     

       301
       301
       -
                           (x) => x.ext === dep.ext && x.id === dep.id

     

       302
       302
       -
                         )

     

       267
       267
       +
                       ? injectedWpModules.find((x) => x.ext === dep.ext && x.id === dep.id)

     

       303
       268
        
                       : injectedWpModules.find((x) => x.id === dep.id)

     

       304
       269
        
                   ) {

     

       305
       270
        
                     deps.delete(dep);

     
···

       330
       295
        
           if (!webpackModules.size) break;

     

       331
       296
        
         }

     

       332
       297
        
       

     

       333
       333
       -
         for (const [name, func] of Object.entries(

     

       334
       334
       -
           moonlight.moonmap.getWebpackModules("window.moonlight.moonmap")

     

       335
       335
       -
         )) {

     

       298
       298
       +
         for (const [name, func] of Object.entries(moonlight.moonmap.getWebpackModules("window.moonlight.moonmap"))) {

     

       336
       299
        
           injectedWpModules.push({ id: name, run: func });

     

       337
       300
        
           modules[name] = func;

     

       338
       301
        
           inject = true;

     
···

       452
       415
        
               });

     

       453
       416
        
               patchModules(modules);

     

       454
       417
        
       

     

       455
       455
       -
               if (!window.webpackChunkdiscord_app)

     

       456
       456
       -
                 window.webpackChunkdiscord_app = [];

     

       418
       418
       +
               if (!window.webpackChunkdiscord_app) window.webpackChunkdiscord_app = [];

     

       457
       419
        
               injectModules(modules);

     

       458
       420
        
             }

     

       459
       421

+2 -12

packages/core/src/persist.ts

···

       1
       1
        
       import { join, dirname } from "node:path";

     

       2
       2
       -
       import {

     

       3
       3
       -
         mkdirSync,

     

       4
       4
       -
         renameSync,

     

       5
       5
       -
         existsSync,

     

       6
       6
       -
         copyFileSync,

     

       7
       7
       -
         readdirSync

     

       8
       8
       -
       } from "node:fs";

     

       2
       2
       +
       import { mkdirSync, renameSync, existsSync, copyFileSync, readdirSync } from "node:fs";

     

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

     

       10
       4
        
       

     

       11
       5
        
       const logger = new Logger("core/persist");

     
···

       31
       25
        
           if (event === "host-updated") {

     

       32
       26
        
             const versions = this.queryCurrentVersionsSync();

     

       33
       27
        
       

     

       34
       34
       -
             const newRootDir = join(

     

       35
       35
       -
               this.rootPath,

     

       36
       36
       -
               "app-" +

     

       37
       37
       -
                 versions.current_host.map((v: number) => v.toString()).join(".")

     

       38
       38
       -
             );

     

       28
       28
       +
             const newRootDir = join(this.rootPath, "app-" + versions.current_host.map((v: number) => v.toString()).join("."));

     

       39
       29
        
             logger.info(`Persisting moonlight - new root dir: ${newRootDir}`);

     

       40
       30
        
       

     

       41
       31
        
             const newResources = join(newRootDir, "resources");

+1 -4

packages/core/src/util/binary.ts

···

       55
       55
        
           return data;

     

       56
       56
        
         }

     

       57
       57
        
       

     

       58
       58
       -
         private _read<T>(

     

       59
       59
       -
           func: (position: number, littleEndian?: boolean) => T,

     

       60
       60
       -
           length: number

     

       61
       61
       -
         ): T {

     

       58
       58
       +
         private _read<T>(func: (position: number, littleEndian?: boolean) => T, length: number): T {

     

       62
       59
        
           const result = func.call(this.view, this.position, true);

     

       63
       60
        
           this.position += length;

     

       64
       61
        
           return result;

+2 -7

packages/core/src/util/data.ts

···

       36
       36
        
       

     

       37
       37
        
         let configPath = "";

     

       38
       38
        
       

     

       39
       39
       -
         const buildInfoPath = moonlightFS.join(

     

       40
       40
       -
           process.resourcesPath,

     

       41
       41
       -
           "build_info.json"

     

       42
       42
       -
         );

     

       39
       39
       +
         const buildInfoPath = moonlightFS.join(process.resourcesPath, "build_info.json");

     

       43
       40
        
         if (!(await moonlightFS.exists(buildInfoPath))) {

     

       44
       41
        
           configPath = moonlightFS.join(dir, "desktop.json");

     

       45
       42
        
         } else {

     

       46
       46
       -
           const buildInfo: BuildInfo = JSON.parse(

     

       47
       47
       -
             await moonlightFS.readFileString(buildInfoPath)

     

       48
       48
       -
           );

     

       43
       43
       +
           const buildInfo: BuildInfo = JSON.parse(await moonlightFS.readFileString(buildInfoPath));

     

       49
       44
        
           configPath = moonlightFS.join(dir, buildInfo.releaseChannel + ".json");

     

       50
       45
        
         }

     

       51
       46

+4 -12

packages/core/src/util/dependency.ts

···

       120
       120
        
                 validateDeps({ id, data });

     

       121
       121
        
               }

     

       122
       122
        
             } else {

     

       123
       123
       -
               const dependsOnMe = Array.from(dependencyGraphOrig.entries()).filter(

     

       124
       124
       -
                 ([, v]) => v?.has(dep.id)

     

       125
       125
       -
               );

     

       123
       123
       +
               const dependsOnMe = Array.from(dependencyGraphOrig.entries()).filter(([, v]) => v?.has(dep.id));

     

       126
       124
        
       

     

       127
       125
        
               if (dependsOnMe.length > 0) {

     

       128
       126
        
                 logger.debug("Implicitly enabling dependency", dep.id);

     
···

       132
       130
        
           }

     

       133
       131
        
       

     

       134
       132
        
           for (const dep of itemsOrig) validateDeps(dep);

     

       135
       135
       -
           itemsOrig = itemsOrig.filter(

     

       136
       136
       -
             (x) => getEnabled(x) || implicitlyEnabled.includes(x.id)

     

       137
       137
       -
           );

     

       133
       133
       +
           itemsOrig = itemsOrig.filter((x) => getEnabled(x) || implicitlyEnabled.includes(x.id));

     

       138
       134
        
         }

     

       139
       135
        
       

     

       140
       136
        
         if (getIncompatible != null) {

     
···

       174
       170
        
           dependencyGraph.set(item.id, new Set(dependencyGraph.get(item.id)));

     

       175
       171
        
         }

     

       176
       172
        
       

     

       177
       177
       -
         while (

     

       178
       178
       -
           Array.from(dependencyGraph.values()).filter((x) => x != null).length > 0

     

       179
       179
       -
         ) {

     

       180
       180
       -
           const noDependents = items.filter(

     

       181
       181
       -
             (e) => dependencyGraph.get(e.id)?.size === 0

     

       182
       182
       -
           );

     

       173
       173
       +
         while (Array.from(dependencyGraph.values()).filter((x) => x != null).length > 0) {

     

       174
       174
       +
           const noDependents = items.filter((e) => dependencyGraph.get(e.id)?.size === 0);

     

       183
       175
        
       

     

       184
       176
        
           if (noDependents.length === 0) {

     

       185
       177
        
             logger.warn("Stuck dependency graph detected", dependencyGraph);

+7 -27

packages/core/src/util/event.ts

···

       9
       9
        
           const listeners = new Map<(data: EventData) => void, (e: Event) => void>();

     

       10
       10
        
       

     

       11
       11
        
           return {

     

       12
       12
       -
             dispatchEvent: <Id extends keyof EventData>(

     

       13
       13
       -
               id: Id,

     

       14
       14
       -
               data: EventData[Id]

     

       15
       15
       -
             ) => {

     

       16
       16
       -
               eventEmitter.dispatchEvent(

     

       17
       17
       -
                 new CustomEvent(id as string, { detail: data })

     

       18
       18
       -
               );

     

       12
       12
       +
             dispatchEvent: <Id extends keyof EventData>(id: Id, data: EventData[Id]) => {

     

       13
       13
       +
               eventEmitter.dispatchEvent(new CustomEvent(id as string, { detail: data }));

     

       19
       14
        
             },

     

       20
       15
        
       

     

       21
       21
       -
             addEventListener: <Id extends keyof EventData>(

     

       22
       22
       -
               id: Id,

     

       23
       23
       -
               cb: (data: EventData[Id]) => void

     

       24
       24
       -
             ) => {

     

       16
       16
       +
             addEventListener: <Id extends keyof EventData>(id: Id, cb: (data: EventData[Id]) => void) => {

     

       25
       17
        
               const untyped = cb as (data: EventData) => void;

     

       26
       18
        
               if (listeners.has(untyped)) return;

     

       27
       19
        
       

     
···

       34
       26
        
               eventEmitter.addEventListener(id as string, listener);

     

       35
       27
        
             },

     

       36
       28
        
       

     

       37
       37
       -
             removeEventListener: <Id extends keyof EventData>(

     

       38
       38
       -
               id: Id,

     

       39
       39
       -
               cb: (data: EventData[Id]) => void

     

       40
       40
       -
             ) => {

     

       29
       29
       +
             removeEventListener: <Id extends keyof EventData>(id: Id, cb: (data: EventData[Id]) => void) => {

     

       41
       30
        
               const untyped = cb as (data: EventData) => void;

     

       42
       31
        
               const listener = listeners.get(untyped);

     

       43
       32
        
               if (listener == null) return;

     
···

       53
       42
        
           const listeners = new Map<(data: EventData) => void, (e: Event) => void>();

     

       54
       43
        
       

     

       55
       44
        
           return {

     

       56
       56
       -
             dispatchEvent: <Id extends keyof EventData>(

     

       57
       57
       -
               id: Id,

     

       58
       58
       -
               data: EventData[Id]

     

       59
       59
       -
             ) => {

     

       45
       45
       +
             dispatchEvent: <Id extends keyof EventData>(id: Id, data: EventData[Id]) => {

     

       60
       46
        
               eventEmitter.emit(id as string, data);

     

       61
       47
        
             },

     

       62
       48
        
       

     

       63
       63
       -
             addEventListener: <Id extends keyof EventData>(

     

       64
       64
       -
               id: Id,

     

       65
       65
       -
               cb: (data: EventData[Id]) => void

     

       66
       66
       -
             ) => {

     

       49
       49
       +
             addEventListener: <Id extends keyof EventData>(id: Id, cb: (data: EventData[Id]) => void) => {

     

       67
       50
        
               const untyped = cb as (data: EventData) => void;

     

       68
       51
        
               if (listeners.has(untyped)) return;

     

       69
       52
        
       

     
···

       76
       59
        
               eventEmitter.on(id as string, listener);

     

       77
       60
        
             },

     

       78
       61
        
       

     

       79
       79
       -
             removeEventListener: <Id extends keyof EventData>(

     

       80
       80
       -
               id: Id,

     

       81
       81
       -
               cb: (data: EventData[Id]) => void

     

       82
       82
       -
             ) => {

     

       62
       62
       +
             removeEventListener: <Id extends keyof EventData>(id: Id, cb: (data: EventData[Id]) => void) => {

     

       83
       63
        
               const untyped = cb as (data: EventData) => void;

     

       84
       64
        
               const listener = listeners.get(untyped);

     

       85
       65
        
               if (listener == null) return;

+1 -3

packages/core/src/util/import.ts

···

       17
       17
        
         fs: typeof import("fs");

     

       18
       18
        
       };

     

       19
       19
        
       

     

       20
       20
       -
       export default function requireImport<T extends CanRequire>(

     

       21
       21
       -
         type: T

     

       22
       22
       -
       ): Awaited<ImportTypes[T]> {

     

       20
       20
       +
       export default function requireImport<T extends CanRequire>(type: T): Awaited<ImportTypes[T]> {

     

       23
       21
        
         return require(type);

     

       24
       22
        
       }

+2 -8

packages/core/src/util/logger.ts

···

       50
       50
        
           if (maxLevel > level) return;

     

       51
       51
        
       

     

       52
       52
        
           if (MOONLIGHT_WEB_PRELOAD || MOONLIGHT_BROWSER) {

     

       53
       53
       -
             args = [

     

       54
       54
       -
               `%c[${logLevel}]`,

     

       55
       55
       -
               `background-color: ${colors[level]}; color: #FFFFFF;`,

     

       56
       56
       -
               `[${this.name}]`,

     

       57
       57
       -
               ...obj

     

       58
       58
       -
             ];

     

       53
       53
       +
             args = [`%c[${logLevel}]`, `background-color: ${colors[level]}; color: #FFFFFF;`, `[${this.name}]`, ...obj];

     

       59
       54
        
           } else {

     

       60
       55
        
             args = [`[${logLevel}]`, `[${this.name}]`, ...obj];

     

       61
       56
        
           }

     
···

       87
       82
        
       

     

       88
       83
        
       export function initLogger(config: Config) {

     

       89
       84
        
         if (config.loggerLevel != null) {

     

       90
       90
       -
           const enumValue =

     

       91
       91
       -
             LogLevel[config.loggerLevel.toUpperCase() as keyof typeof LogLevel];

     

       85
       85
       +
           const enumValue = LogLevel[config.loggerLevel.toUpperCase() as keyof typeof LogLevel];

     

       92
       86
        
           if (enumValue != null) {

     

       93
       87
        
             maxLevel = enumValue;

     

       94
       88
        
           }

+8 -31

packages/injector/src/index.ts

···

       9
       9
        
       import { readConfig } from "@moonlight-mod/core/config";

     

       10
       10
        
       import { getExtensions } from "@moonlight-mod/core/extension";

     

       11
       11
        
       import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     

       12
       12
       -
       import {

     

       13
       13
       -
         loadExtensions,

     

       14
       14
       -
         loadProcessedExtensions

     

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

     

       12
       12
       +
       import { loadExtensions, loadProcessedExtensions } from "@moonlight-mod/core/extension/loader";

     

       16
       13
        
       import EventEmitter from "node:events";

     

       17
       14
        
       import { join, resolve } from "node:path";

     

       18
       15
        
       import persist from "@moonlight-mod/core/persist";

     
···

       44
       41
        
       });

     

       45
       42
        
       

     

       46
       43
        
       const reEscapeRegExp = /[\\^$.*+?()[\]{}|]/g;

     

       47
       47
       -
       const reMatchPattern =

     

       48
       48
       -
         /^(?<scheme>\*|[a-z][a-z0-9+.-]*):\/\/(?<host>.+?)\/(?<path>.+)?$/;

     

       44
       44
       +
       const reMatchPattern = /^(?<scheme>\*|[a-z][a-z0-9+.-]*):\/\/(?<host>.+?)\/(?<path>.+)?$/;

     

       49
       45
        
       

     

       50
       46
        
       const escapeRegExp = (s: string) => s.replace(reEscapeRegExp, "\\$&");

     

       51
       47
        
       ipcMain.handle(constants.ipcSetBlockedList, (_, list: string[]) => {

     
···

       77
       73
        
       });

     

       78
       74
        
       

     

       79
       75
        
       function patchCsp(headers: Record<string, string[]>) {

     

       80
       80
       -
         const directives = [

     

       81
       81
       -
           "style-src",

     

       82
       82
       -
           "connect-src",

     

       83
       83
       -
           "img-src",

     

       84
       84
       -
           "font-src",

     

       85
       85
       -
           "media-src",

     

       86
       86
       -
           "worker-src",

     

       87
       87
       -
           "prefetch-src"

     

       88
       88
       -
         ];

     

       76
       76
       +
         const directives = ["style-src", "connect-src", "img-src", "font-src", "media-src", "worker-src", "prefetch-src"];

     

       89
       77
        
         const values = ["*", "blob:", "data:", "'unsafe-inline'", "disclip:"];

     

       90
       78
        
       

     

       91
       79
        
         const csp = "content-security-policy";

     
···

       124
       112
        
         constructor(opts: BrowserWindowConstructorOptions) {

     

       125
       113
        
           oldPreloadPath = opts.webPreferences!.preload;

     

       126
       114
        
       

     

       127
       127
       -
           const isMainWindow =

     

       128
       128
       -
             opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1;

     

       115
       115
       +
           const isMainWindow = opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1;

     

       129
       116
        
       

     

       130
       130
       -
           if (isMainWindow)

     

       131
       131
       -
             opts.webPreferences!.preload = require.resolve("./node-preload.js");

     

       117
       117
       +
           if (isMainWindow) opts.webPreferences!.preload = require.resolve("./node-preload.js");

     

       132
       118
        
       

     

       133
       119
        
           // Event for modifying window options

     

       134
       120
        
           moonlightHost.events.emit("window-options", opts, isMainWindow);

     
···

       258
       244
        
             // Someone can always make a command line modifier plugin, thats the point

     

       259
       245
        
             // of having host modules.

     

       260
       246
        
             try {

     

       261
       261
       -
               const cmdSwitchesPath = require.resolve(

     

       262
       262
       -
                 join(asarPath, "cmdSwitches.js")

     

       263
       263
       -
               );

     

       264
       264
       -
               require.cache[cmdSwitchesPath] = new Module(

     

       265
       265
       -
                 cmdSwitchesPath,

     

       266
       266
       -
                 require.cache[require.resolve(asarPath)]

     

       267
       267
       -
               );

     

       247
       247
       +
               const cmdSwitchesPath = require.resolve(join(asarPath, "cmdSwitches.js"));

     

       248
       248
       +
               require.cache[cmdSwitchesPath] = new Module(cmdSwitchesPath, require.cache[require.resolve(asarPath)]);

     

       268
       249
        
               require.cache[cmdSwitchesPath]!.exports = () => {};

     

       269
       250
        
             } catch (error) {

     

       270
       251
        
               logger.error("Failed to disable OpenAsar's command line flags:", error);

     
···

       301
       282
        
               configurable: false

     

       302
       283
        
             });

     

       303
       284
        
           } else {

     

       304
       304
       -
             Object.defineProperty(

     

       305
       305
       -
               electronClone,

     

       306
       306
       -
               property,

     

       307
       307
       -
               Object.getOwnPropertyDescriptor(electron, property)!

     

       308
       308
       -
             );

     

       285
       285
       +
             Object.defineProperty(electronClone, property, Object.getOwnPropertyDescriptor(electron, property)!);

     

       309
       286
        
           }

     

       310
       287
        
         }

     

       311
       288

+5 -17

packages/node-preload/src/index.ts

···

       5
       5
        
       import { readConfig, writeConfig } from "@moonlight-mod/core/config";

     

       6
       6
        
       import { constants, MoonlightBranch } from "@moonlight-mod/types";

     

       7
       7
        
       import { getExtensions } from "@moonlight-mod/core/extension";

     

       8
       8
       -
       import {

     

       9
       9
       -
         getExtensionsPath,

     

       10
       10
       -
         getMoonlightDir

     

       11
       11
       -
       } from "@moonlight-mod/core/util/data";

     

       8
       8
       +
       import { getExtensionsPath, getMoonlightDir } from "@moonlight-mod/core/util/data";

     

       12
       9
        
       import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     

       13
       13
       -
       import {

     

       14
       14
       -
         loadExtensions,

     

       15
       15
       -
         loadProcessedExtensions

     

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

     

       10
       10
       +
       import { loadExtensions, loadProcessedExtensions } from "@moonlight-mod/core/extension/loader";

     

       17
       11
        
       import createFS from "@moonlight-mod/core/fs";

     

       18
       12
        
       

     

       19
       13
        
       async function injectGlobals() {

     
···

       67
       61
        
         await loadProcessedExtensions(processedExtensions);

     

       68
       62
        
         contextBridge.exposeInMainWorld("moonlightNode", moonlightNode);

     

       69
       63
        
       

     

       70
       70
       -
         const extCors = moonlightNode.processedExtensions.extensions.flatMap(

     

       71
       71
       -
           (x) => x.manifest.cors ?? []

     

       72
       72
       -
         );

     

       64
       64
       +
         const extCors = moonlightNode.processedExtensions.extensions.flatMap((x) => x.manifest.cors ?? []);

     

       73
       65
        
       

     

       74
       66
        
         for (const repo of moonlightNode.config.repositories) {

     

       75
       67
        
           const url = new URL(repo);

     
···

       79
       71
        
       

     

       80
       72
        
         ipcRenderer.invoke(constants.ipcSetCorsList, extCors);

     

       81
       73
        
       

     

       82
       82
       -
         const extBlocked = moonlightNode.processedExtensions.extensions.flatMap(

     

       83
       83
       -
           (e) => e.manifest.blocked ?? []

     

       84
       84
       -
         );

     

       74
       74
       +
         const extBlocked = moonlightNode.processedExtensions.extensions.flatMap((e) => e.manifest.blocked ?? []);

     

       85
       75
        
         ipcRenderer.invoke(constants.ipcSetBlockedList, extBlocked);

     

       86
       76
        
       }

     

       87
       77
        
       

     
···

       107
       97
        
         if (oldPreloadPath) require(oldPreloadPath);

     

       108
       98
        
       }

     

       109
       99
        
       

     

       110
       110
       -
       const oldPreloadPath: string = ipcRenderer.sendSync(

     

       111
       111
       -
         constants.ipcGetOldPreloadPath

     

       112
       112
       -
       );

     

       100
       100
       +
       const oldPreloadPath: string = ipcRenderer.sendSync(constants.ipcGetOldPreloadPath);

     

       113
       101
        
       init(oldPreloadPath);

+1 -3

packages/types/src/config.ts

···

       6
       6
        
         patchAll?: boolean;

     

       7
       7
        
       };

     

       8
       8
        
       

     

       9
       9
       -
       export type ConfigExtensions =

     

       10
       10
       -
         | { [key: string]: boolean }

     

       11
       11
       -
         | { [key: string]: ConfigExtension };

     

       9
       9
       +
       export type ConfigExtensions = { [key: string]: boolean } | { [key: string]: ConfigExtension };

     

       12
       10
        
       

     

       13
       11
        
       export type ConfigExtension = {

     

       14
       12
        
         enabled: boolean;

+1 -2

packages/types/src/constants.ts

···

       13
       13
        
       

     

       14
       14
        
       export const apiLevel = 2;

     

       15
       15
        
       

     

       16
       16
       -
       export const mainRepo =

     

       17
       17
       -
         "https://moonlight-mod.github.io/extensions-dist/repo.json";

     

       16
       16
       +
       export const mainRepo = "https://moonlight-mod.github.io/extensions-dist/repo.json";

+4 -16

packages/types/src/core/event.ts

···

       1
       1
        
       import { WebpackModuleFunc, WebpackRequireType } from "../discord";

     

       2
       2
        
       

     

       3
       3
       -
       export interface MoonlightEventEmitter<

     

       4
       4
       -
         EventId extends string = string,

     

       5
       5
       -
         EventData = Record<EventId, any>

     

       6
       6
       -
       > {

     

       7
       7
       -
         dispatchEvent: <Id extends keyof EventData>(

     

       8
       8
       -
           id: Id,

     

       9
       9
       -
           data: EventData[Id]

     

       10
       10
       -
         ) => void;

     

       11
       11
       -
         addEventListener: <Id extends keyof EventData>(

     

       12
       12
       -
           id: Id,

     

       13
       13
       -
           cb: (data: EventData[Id]) => void

     

       14
       14
       -
         ) => void;

     

       15
       15
       -
         removeEventListener: <Id extends keyof EventData>(

     

       16
       16
       -
           id: Id,

     

       17
       17
       -
           cb: (data: EventData[Id]) => void

     

       18
       18
       -
         ) => void;

     

       3
       3
       +
       export interface MoonlightEventEmitter<EventId extends string = string, EventData = Record<EventId, any>> {

     

       4
       4
       +
         dispatchEvent: <Id extends keyof EventData>(id: Id, data: EventData[Id]) => void;

     

       5
       5
       +
         addEventListener: <Id extends keyof EventData>(id: Id, cb: (data: EventData[Id]) => void) => void;

     

       6
       6
       +
         removeEventListener: <Id extends keyof EventData>(id: Id, cb: (data: EventData[Id]) => void) => void;

     

       19
       7
        
       }

     

       20
       8
        
       

     

       21
       9
        
       export enum EventType {

+2 -10

packages/types/src/coreExtensions/contextMenu.ts

···

       11
       11
        
       }>;

     

       12
       12
        
       export type MenuProps = React.ComponentProps<Menu>;

     

       13
       13
        
       

     

       14
       14
       -
       export type MenuElement =

     

       15
       15
       -
         | MenuSeparator

     

       16
       16
       -
         | MenuGroup

     

       17
       17
       -
         | MenuItem

     

       18
       18
       -
         | MenuCheckboxItem

     

       19
       19
       -
         | MenuRadioItem

     

       20
       20
       -
         | MenuControlItem;

     

       14
       14
       +
       export type MenuElement = MenuSeparator | MenuGroup | MenuItem | MenuCheckboxItem | MenuRadioItem | MenuControlItem;

     

       21
       15
        
       

     

       22
       16
        
       export type MenuSeparator = React.FunctionComponent;

     

       23
       17
        
       export type MenuGroup = React.FunctionComponent<{

     
···

       156
       150
        
       };

     

       157
       151
        
       

     

       158
       152
        
       export type EvilItemParser = (

     

       159
       159
       -
         el:

     

       160
       160
       -
           | React.ReactComponentElement<MenuElement>

     

       161
       161
       -
           | React.ReactComponentElement<MenuElement>[]

     

       153
       153
       +
         el: React.ReactComponentElement<MenuElement> | React.ReactComponentElement<MenuElement>[]

     

       162
       154
        
       ) => InternalItem[];

+5 -23

packages/types/src/coreExtensions/markdown.ts

···

       11
       11
        
       

     

       12
       12
        
       export type ASTNode = SingleASTNode | Array<SingleASTNode>;

     

       13
       13
        
       

     

       14
       14
       -
       export type Parser = (

     

       15
       15
       -
         source: string,

     

       16
       16
       -
         state?: State | null | undefined

     

       17
       17
       -
       ) => Array<SingleASTNode>;

     

       14
       14
       +
       export type Parser = (source: string, state?: State | null | undefined) => Array<SingleASTNode>;

     

       18
       15
        
       

     

       19
       19
       -
       export type ParseFunction = (

     

       20
       20
       -
         capture: Capture,

     

       21
       21
       -
         nestedParse: Parser,

     

       22
       22
       -
         state: State

     

       23
       23
       -
       ) => UntypedASTNode | ASTNode;

     

       16
       16
       +
       export type ParseFunction = (capture: Capture, nestedParse: Parser, state: State) => UntypedASTNode | ASTNode;

     

       24
       17
        
       

     

       25
       18
        
       export type Capture =

     

       26
       19
        
         | (Array<string> & {

     
···

       38
       31
        
       

     

       39
       32
        
       export type MatchFunction = {

     

       40
       33
        
         regex?: RegExp;

     

       41
       41
       -
       } & ((

     

       42
       42
       -
         source: string,

     

       43
       43
       -
         state: State,

     

       44
       44
       -
         prevCapture: string

     

       45
       45
       -
       ) => Capture | null | undefined);

     

       34
       34
       +
       } & ((source: string, state: State, prevCapture: string) => Capture | null | undefined);

     

       46
       35
        
       

     

       47
       47
       -
       export type Output<Result> = (

     

       48
       48
       -
         node: ASTNode,

     

       49
       49
       -
         state?: State | null | undefined

     

       50
       50
       -
       ) => Result;

     

       36
       36
       +
       export type Output<Result> = (node: ASTNode, state?: State | null | undefined) => Result;

     

       51
       37
        
       

     

       52
       52
       -
       export type SingleNodeOutput<Result> = (

     

       53
       53
       -
         node: SingleASTNode,

     

       54
       54
       -
         nestedOutput: Output<Result>,

     

       55
       55
       -
         state: State

     

       56
       56
       -
       ) => Result;

     

       38
       38
       +
       export type SingleNodeOutput<Result> = (node: SingleASTNode, nestedOutput: Output<Result>, state: State) => Result;

     

       57
       39
        
       

     

       58
       40
        
       // }}}

     

       59
       41

+1 -5

packages/types/src/coreExtensions/moonbase.ts

···

       4
       4
        
       }>;

     

       5
       5
        
       

     

       6
       6
        
       export type Moonbase = {

     

       7
       7
       -
         registerConfigComponent: (

     

       8
       8
       -
           ext: string,

     

       9
       9
       -
           option: string,

     

       10
       10
       -
           component: CustomComponent

     

       11
       11
       -
         ) => void;

     

       7
       7
       +
         registerConfigComponent: (ext: string, option: string, component: CustomComponent) => void;

     

       12
       8
        
       };

+3 -15

packages/types/src/coreExtensions/spacepack.ts

···

       1
       1
       -
       import {

     

       2
       2
       -
         WebpackModule,

     

       3
       3
       -
         WebpackModuleFunc,

     

       4
       4
       -
         WebpackRequireType

     

       5
       5
       -
       } from "../discord";

     

       1
       1
       +
       import { WebpackModule, WebpackModuleFunc, WebpackRequireType } from "../discord";

     

       6
       2
        
       

     

       7
       3
        
       export type Spacepack = {

     

       8
       4
        
         inspect: (module: number | string) => WebpackModuleFunc | null;

     
···

       13
       9
        
         cache: Record<string, any>;

     

       14
       10
        
         findObjectFromKey: (exports: Record<string, any>, key: string) => any | null;

     

       15
       11
        
         findObjectFromValue: (exports: Record<string, any>, value: any) => any | null;

     

       16
       16
       -
         findObjectFromKeyValuePair: (

     

       17
       17
       -
           exports: Record<string, any>,

     

       18
       18
       -
           key: string,

     

       19
       19
       -
           value: any

     

       20
       20
       -
         ) => any | null;

     

       12
       12
       +
         findObjectFromKeyValuePair: (exports: Record<string, any>, key: string, value: any) => any | null;

     

       21
       13
        
         findFunctionByStrings: (

     

       22
       14
        
           exports: Record<string, any>,

     

       23
       15
        
           ...strings: (string | RegExp)[]

     

       24
       16
        
           // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type

     

       25
       17
        
         ) => Function | null;

     

       26
       26
       -
         lazyLoad: (

     

       27
       27
       -
           find: string | RegExp | (string | RegExp)[],

     

       28
       28
       -
           chunk: RegExp,

     

       29
       29
       -
           module: RegExp

     

       30
       30
       -
         ) => Promise<any>;

     

       18
       18
       +
         lazyLoad: (find: string | RegExp | (string | RegExp)[], chunk: RegExp, module: RegExp) => Promise<any>;

     

       31
       19
        
         filterReal: (modules: WebpackModule[]) => WebpackModule[];

     

       32
       20
        
       };

+2 -10

packages/types/src/discord/webpack.ts

···

       14
       14
        
         exports: any;

     

       15
       15
        
       };

     

       16
       16
        
       

     

       17
       17
       -
       export type WebpackModuleFunc = ((

     

       18
       18
       -
         module: any,

     

       19
       19
       -
         exports: any,

     

       20
       20
       -
         require: WebpackRequireType

     

       21
       21
       -
       ) => void) & {

     

       17
       17
       +
       export type WebpackModuleFunc = ((module: any, exports: any, require: WebpackRequireType) => void) & {

     

       22
       18
        
         __moonlight?: boolean;

     

       23
       19
        
       };

     

       24
       20
        
       

     

       25
       25
       -
       export type WebpackJsonpEntry = [

     

       26
       26
       -
         number[],

     

       27
       27
       -
         { [id: string]: WebpackModuleFunc },

     

       28
       28
       -
         (require: WebpackRequireType) => any

     

       29
       29
       -
       ];

     

       21
       21
       +
       export type WebpackJsonpEntry = [number[], { [id: string]: WebpackModuleFunc }, (require: WebpackRequireType) => any];

     

       30
       22
        
       

     

       31
       23
        
       export type WebpackJsonp = WebpackJsonpEntry[] & {

     

       32
       24
        
         push: {

+1 -2

packages/types/src/extension.ts

···

       133
       133
        
         id: number;

     

       134
       134
        
       };

     

       135
       135
        
       

     

       136
       136
       -
       export type IdentifiedWebpackModule = ExtensionWebpackModule &

     

       137
       137
       -
         ExplicitExtensionDependency;

     

       136
       136
       +
       export type IdentifiedWebpackModule = ExtensionWebpackModule & ExplicitExtensionDependency;

+3 -15

packages/types/src/globals.ts

···

       1
       1
        
       import type { Logger } from "./logger";

     

       2
       2
        
       import type { Config, ConfigExtension } from "./config";

     

       3
       3
       -
       import type {

     

       4
       4
       -
         DetectedExtension,

     

       5
       5
       -
         IdentifiedPatch,

     

       6
       6
       -
         IdentifiedWebpackModule,

     

       7
       7
       -
         ProcessedExtensions

     

       8
       8
       -
       } from "./extension";

     

       3
       3
       +
       import type { DetectedExtension, IdentifiedPatch, IdentifiedWebpackModule, ProcessedExtensions } from "./extension";

     

       9
       4
        
       import type EventEmitter from "events";

     

       10
       5
        
       import type LunAST from "@moonlight-mod/lunast";

     

       11
       6
        
       import type Moonmap from "@moonlight-mod/moonmap";

     

       12
       12
       -
       import type {

     

       13
       13
       -
         EventPayloads,

     

       14
       14
       -
         EventType,

     

       15
       15
       -
         MoonlightEventEmitter

     

       16
       16
       -
       } from "./core/event";

     

       7
       7
       +
       import type { EventPayloads, EventType, MoonlightEventEmitter } from "./core/event";

     

       17
       8
        
       

     

       18
       9
        
       export type MoonlightHost = {

     

       19
       10
        
         asarPath: string;

     
···

       57
       48
        
         apiLevel: number;

     

       58
       49
        
         events: MoonlightEventEmitter<EventType, EventPayloads>;

     

       59
       50
        
         patchingInternals: {

     

       60
       60
       -
           onModuleLoad: (

     

       61
       61
       -
             moduleId: string | string[],

     

       62
       62
       -
             callback: (moduleId: string) => void

     

       63
       63
       -
           ) => void;

     

       51
       51
       +
           onModuleLoad: (moduleId: string | string[], callback: (moduleId: string) => void) => void;

     

       64
       52
        
           registerPatch: (patch: IdentifiedPatch) => void;

     

       65
       53
        
           registerWebpackModule: (module: IdentifiedWebpackModule) => void;

     

       66
       54
        
         };

+1 -6

packages/types/src/index.ts

···

       5
       5
        
       /* eslint-disable no-var */

     

       6
       6
        
       

     

       7
       7
        
       import { MoonlightFS } from "./fs";

     

       8
       8
       -
       import {

     

       9
       9
       -
         MoonlightEnv,

     

       10
       10
       -
         MoonlightHost,

     

       11
       11
       -
         MoonlightNode,

     

       12
       12
       -
         MoonlightWeb

     

       13
       13
       -
       } from "./globals";

     

       8
       8
       +
       import { MoonlightEnv, MoonlightHost, MoonlightNode, MoonlightWeb } from "./globals";

     

       14
       9
        
       

     

       15
       10
        
       export * from "./discord";

     

       16
       11
        
       export * from "./config";

+1 -6

packages/web-preload/src/index.ts

···

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

     

       2
       2
       -
       import {

     

       3
       3
       -
         installWebpackPatcher,

     

       4
       4
       -
         onModuleLoad,

     

       5
       5
       -
         registerPatch,

     

       6
       6
       -
         registerWebpackModule

     

       7
       7
       -
       } from "@moonlight-mod/core/patch";

     

       2
       2
       +
       import { installWebpackPatcher, onModuleLoad, registerPatch, registerWebpackModule } from "@moonlight-mod/core/patch";

     

       8
       3
        
       import { constants, MoonlightBranch } from "@moonlight-mod/types";

     

       9
       4
        
       import { installStyles } from "@moonlight-mod/core/styles";

     

       10
       5
        
       import Logger, { initLogger } from "@moonlight-mod/core/util/logger";