···

       
1
       
 
       
{

     

       
2
       
-
       
  "printWidth": 80,

     

       
3
       
 
       
  "trailingComma": "none",

     

       
4
       
 
       
  "tabWidth": 2,

     

       
5
       
 
       
  "singleQuote": false

     

···

       
1
       
 
       
{

     

       
2
       
+
       
  "printWidth": 120,

     

       
3
       
 
       
  "trailingComma": "none",

     

       
4
       
 
       
  "tabWidth": 2,

     

       
5
       
 
       
  "singleQuote": false

     

···

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

     

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

     

       
19
       
 
       
    "lint": "eslint packages",

     

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

     

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

     

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

     

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

     

···

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

     

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

     

       
19
       
 
       
    "lint": "eslint packages",

     

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

     

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

     

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

     

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

     

···

       
79
       
 
       
          args: [urls],

     

       
80
       
 
       
          func: async (urls) => {

     

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

     

       
82
       
-
       
              (script) =>

     

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

     

       
84
       
 
       
            );

     

       
85
       
 
       


     

       
86
       
 
       
            // backwards

     

···

       
79
       
 
       
          args: [urls],

     

       
80
       
 
       
          func: async (urls) => {

     

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

     

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

     

       
0
       
 
       

     

       
83
       
 
       
            );

     

       
84
       
 
       


     

       
85
       
 
       
            // backwards

     

···

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

     

       
6
       
 
       
    replace: [

     

       
7
       
 
       
      {

     

       
8
       
-
       
        match:

     

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

     

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

     

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

     

       
12
       
 
       
      }

     
···

       
17
       
 
       
    replace: [

     

       
18
       
 
       
      {

     

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

     

       
20
       
-
       
        replacement: (render) =>

     

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

     

       
22
       
 
       
      }

     

       
23
       
 
       
    ]

     

       
24
       
 
       
  }

     
···

       
26
       
 
       


     

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

     

       
28
       
 
       
  contextMenu: {

     

       
29
       
-
       
    dependencies: [

     

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

     

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

     

       
32
       
-
       
    ]

     

       
33
       
 
       
  },

     

       
34
       
 
       
  evilMenu: {

     

       
35
       
-
       
    dependencies: [

     

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

     

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

     

       
38
       
-
       
    ]

     

       
39
       
 
       
  }

     

       
40
       
 
       
};

     

···

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

     

       
6
       
 
       
    replace: [

     

       
7
       
 
       
      {

     

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

     

       
0
       
 
       

     

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

     

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

     

       
11
       
 
       
      }

     
···

       
16
       
 
       
    replace: [

     

       
17
       
 
       
      {

     

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

     

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

     

       
0
       
 
       

     

       
20
       
 
       
      }

     

       
21
       
 
       
    ]

     

       
22
       
 
       
  }

     
···

       
24
       
 
       


     

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

     

       
26
       
 
       
  contextMenu: {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
28
       
 
       
  },

     

       
29
       
 
       
  evilMenu: {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
31
       
 
       
  }

     

       
32
       
 
       
};

     

···

       
1
       
-
       
import {

     

       
2
       
-
       
  InternalItem,

     

       
3
       
-
       
  MenuElement,

     

       
4
       
-
       
  MenuProps

     

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

     

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

     

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

     

       
8
       
 
       


     

       
9
       
 
       
type Patch = {

     

       
10
       
 
       
  navId: string;

     

       
11
       
-
       
  item: (

     

       
12
       
-
       
    props: any

     

       
13
       
-
       
  ) =>

     

       
14
       
-
       
    | React.ReactComponentElement<MenuElement>

     

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

     

       
16
       
 
       
  anchorId: string;

     

       
17
       
 
       
  before: boolean;

     

       
18
       
 
       
};

     

       
19
       
 
       


     

       
20
       
 
       
function addItem<T>(

     

       
21
       
 
       
  navId: string,

     

       
22
       
-
       
  item: (

     

       
23
       
-
       
    props: T

     

       
24
       
-
       
  ) =>

     

       
25
       
-
       
    | React.ReactComponentElement<MenuElement>

     

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

     

       
27
       
 
       
  anchorId: string,

     

       
28
       
 
       
  before = false

     

       
29
       
 
       
) {

     
···

       
65
       
 
       
// Unmangle Menu elements

     

       
66
       
 
       
const code =

     

       
67
       
 
       
  spacepack.require.m[

     

       
68
       
-
       
    spacepack.findByCode(

     

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

     

       
70
       
-
       
    )[0].id

     

       
71
       
 
       
  ].toString();

     

       
72
       
 
       


     

       
73
       
 
       
let MangledMenu;

     

···

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
4
       
 
       


     

       
5
       
 
       
type Patch = {

     

       
6
       
 
       
  navId: string;

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       
  anchorId: string;

     

       
9
       
 
       
  before: boolean;

     

       
10
       
 
       
};

     

       
11
       
 
       


     

       
12
       
 
       
function addItem<T>(

     

       
13
       
 
       
  navId: string,

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
15
       
 
       
  anchorId: string,

     

       
16
       
 
       
  before = false

     

       
17
       
 
       
) {

     
···

       
53
       
 
       
// Unmangle Menu elements

     

       
54
       
 
       
const code =

     

       
55
       
 
       
  spacepack.require.m[

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
57
       
 
       
  ].toString();

     

       
58
       
 
       


     

       
59
       
 
       
let MangledMenu;

     

···

       
2
       
 
       


     

       
3
       
 
       
let code =

     

       
4
       
 
       
  spacepack.require.m[

     

       
5
       
-
       
    spacepack.findByCode(

     

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

     

       
7
       
-
       
    )[0].id

     

       
8
       
 
       
  ].toString();

     

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

     

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

     

       
11
       
-
       
const mod = new Function(

     

       
12
       
-
       
  "module",

     

       
13
       
-
       
  "exports",

     

       
14
       
-
       
  "require",

     

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

     

       
16
       
-
       
);

     

       
17
       
 
       
const exp: any = {};

     

       
18
       
 
       
mod({}, exp, require);

     

       
19
       
-
       
const Menu = spacepack.findFunctionByStrings(

     

       
20
       
-
       
  exp,

     

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

     

       
22
       
-
       
)!;

     

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

     

       
24
       
 
       
  return Menu({

     

       
25
       
 
       
    children: el,

     

···

       
2
       
 
       


     

       
3
       
 
       
let code =

     

       
4
       
 
       
  spacepack.require.m[

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       
  ].toString();

     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
10
       
 
       
const exp: any = {};

     

       
11
       
 
       
mod({}, exp, require);

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
14
       
 
       
  return Menu({

     

       
15
       
 
       
    children: el,

     

···

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

     

       
6
       
 
       


     

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

     

       
8
       
-
       
  const paths =

     

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

     

       
10
       
-
       
    [];

     

       
11
       
 
       


     

       
12
       
 
       
  for (const path of paths) {

     

       
13
       
 
       
    const resolved = resolve(path);

     

···

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

     

       
6
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
9
       
 
       


     

       
10
       
 
       
  for (const path of paths) {

     

       
11
       
 
       
    const resolved = resolve(path);

     

···

       
5
       
 
       


     

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

     

       
7
       
 
       
  try {

     

       
8
       
-
       
    const hostSentryPath = require.resolve(

     

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

     

       
10
       
-
       
    );

     

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

     

       
12
       
-
       
      hostSentryPath,

     

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

     

       
14
       
-
       
    );

     

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

     

       
16
       
 
       
      init: () => {},

     

       
17
       
 
       
      captureException: () => {},

     

···

       
5
       
 
       


     

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

     

       
7
       
 
       
  try {

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
11
       
 
       
      init: () => {},

     

       
12
       
 
       
      captureException: () => {},

     

···

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

     

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

     

       
10
       
 
       
  try {

     

       
11
       
-
       
    const sentryPath = require.resolve(

     

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

     

       
13
       
-
       
    );

     

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

     

       
15
       
-
       
      sentryPath,

     

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

     

       
17
       
-
       
    );

     

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

     

       
19
       
 
       
      init: () => {},

     

       
20
       
 
       
      setTag: () => {},

     

···

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

     

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

     

       
10
       
 
       
  try {

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
14
       
 
       
      init: () => {},

     

       
15
       
 
       
      setTag: () => {},

     

···

       
23
       
 
       
            throw Error("crash");

     

       
24
       
 
       
          };

     

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

     

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

     

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

     

       
28
       
 
       
        } else {

     

       
29
       
 
       
          return undefined;

     

       
30
       
 
       
        }

     

···

       
23
       
 
       
            throw Error("crash");

     

       
24
       
 
       
          };

     

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

     

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

     

       
0
       
 
       

     

       
27
       
 
       
        } else {

     

       
28
       
 
       
          return undefined;

     

       
29
       
 
       
        }

     

···

       
6
       
 
       
    replace: [

     

       
7
       
 
       
      {

     

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

     

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

     

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

     

       
11
       
 
       
      },

     

       
12
       
 
       
      {

     

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

     

       
14
       
-
       
        replacement: (_, rulesets) =>

     

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

     

       
16
       
 
       
      }

     

       
17
       
 
       
    ]

     

       
18
       
 
       
  },

     
···

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

     

       
26
       
 
       
      },

     

       
27
       
 
       
      {

     

       
28
       
-
       
        match:

     

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

     

       
30
       
-
       
        replacement: (

     

       
31
       
-
       
          _,

     

       
32
       
-
       
          start,

     

       
33
       
-
       
          rule,

     

       
34
       
-
       
          body,

     

       
35
       
-
       
          plaintextReturn,

     

       
36
       
-
       
          otherRules,

     

       
37
       
-
       
          inlineStyleBody

     

       
38
       
-
       
        ) =>

     

       
39
       
 
       
          `${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
       
 
       
      }

     

       
41
       
 
       
    ]

     
···

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

     

       
45
       
 
       
    replace: {

     

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

     

       
47
       
-
       
      replacement: (_, rules) =>

     

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

     

       
49
       
 
       
    }

     

       
50
       
 
       
  }

     

       
51
       
 
       
];

     

···

       
6
       
 
       
    replace: [

     

       
7
       
 
       
      {

     

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

     

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

     

       
0
       
 
       

     

       
10
       
 
       
      },

     

       
11
       
 
       
      {

     

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

     

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

     

       
0
       
 
       

     

       
14
       
 
       
      }

     

       
15
       
 
       
    ]

     

       
16
       
 
       
  },

     
···

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

     

       
24
       
 
       
      },

     

       
25
       
 
       
      {

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
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:`

     

       
29
       
 
       
      }

     

       
30
       
 
       
    ]

     
···

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

     

       
34
       
 
       
    replace: {

     

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

     

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

     

       
0
       
 
       

     

       
37
       
 
       
    }

     

       
38
       
 
       
  }

     

       
39
       
 
       
];

     

···

       
1
       
-
       
import {

     

       
2
       
-
       
  MarkdownRule,

     

       
3
       
-
       
  Ruleset,

     

       
4
       
-
       
  SlateRule

     

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

     

       
6
       
 
       


     

       
7
       
-
       
export const rules: Record<

     

       
8
       
-
       
  string,

     

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

     

       
10
       
-
       
> = {};

     

       
11
       
-
       
export const slateRules: Record<

     

       
12
       
-
       
  string,

     

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

     

       
14
       
-
       
> = {};

     

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

     

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

     

       
17
       
 
       
  RULES: {},

     
···

       
66
       
 
       
  return originalRules;

     

       
67
       
 
       
}

     

       
68
       
 
       


     

       
69
       
-
       
export function _applyRulesetBlacklist(

     

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

     

       
71
       
-
       
) {

     

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

     

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

     

       
74
       
 
       


     

···

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
7
       
 
       
  RULES: {},

     
···

       
56
       
 
       
  return originalRules;

     

       
57
       
 
       
}

     

       
58
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
62
       
 
       


     

···

       
2
       
 
       


     

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

     

       
4
       
 
       
  stores: {

     

       
5
       
-
       
    dependencies: [

     

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

     

       
7
       
-
       
      { id: "discord/Dispatcher" }

     

       
8
       
-
       
    ]

     

       
9
       
 
       
  },

     

       
10
       
 
       


     

       
11
       
 
       
  ui: {

     

···

       
2
       
 
       


     

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

     

       
4
       
 
       
  stores: {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       
  },

     

       
7
       
 
       


     

       
8
       
 
       
  ui: {

     

···

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

     

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

     

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

     

       
4
       
-
       
import {

     

       
5
       
-
       
  distDir,

     

       
6
       
-
       
  repoUrlFile,

     

       
7
       
-
       
  installedVersionFile

     

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

     

       
9
       
 
       
import { parseTarGzip } from "nanotar";

     

       
10
       
 
       


     

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

     
···

       
121
       
 
       


     

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

     

       
123
       
 
       
        const fullDir = moonlightFS.dirname(fullFile);

     

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

     

       
125
       
-
       
          await moonlightFS.mkdir(fullDir);

     

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

     

       
127
       
 
       
      }

     

       
128
       
 
       


     

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

     

       
130
       
-
       
      const versionFile = moonlightFS.join(

     

       
131
       
-
       
        moonlightNode.getMoonlightDir(),

     

       
132
       
-
       
        installedVersionFile

     

       
133
       
-
       
      );

     

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

     

       
135
       
 
       


     

       
136
       
 
       
      logger.debug("Update extracted");

     
···

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

     

       
177
       
 
       
        const fullDir = moonlightFS.dirname(fullFile);

     

       
178
       
 
       


     

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

     

       
180
       
-
       
          await moonlightFS.mkdir(fullDir);

     

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

     

       
182
       
 
       
      }

     

       
183
       
 
       


     

       
184
       
-
       
      await moonlightFS.writeFileString(

     

       
185
       
-
       
        moonlightFS.join(dir, repoUrlFile),

     

       
186
       
-
       
        repo

     

       
187
       
-
       
      );

     

       
188
       
 
       
    },

     

       
189
       
 
       


     

       
190
       
 
       
    async deleteExtension(id) {

     

···

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

     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
import { parseTarGzip } from "nanotar";

     

       
6
       
 
       


     

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

     
···

       
117
       
 
       


     

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

     

       
119
       
 
       
        const fullDir = moonlightFS.dirname(fullFile);

     

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

     

       
0
       
 
       

     

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

     

       
122
       
 
       
      }

     

       
123
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
127
       
 
       


     

       
128
       
 
       
      logger.debug("Update extracted");

     
···

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

     

       
169
       
 
       
        const fullDir = moonlightFS.dirname(fullFile);

     

       
170
       
 
       


     

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

     

       
0
       
 
       

     

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

     

       
173
       
 
       
      }

     

       
174
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
176
       
 
       
    },

     

       
177
       
 
       


     

       
178
       
 
       
    async deleteExtension(id) {

     

···

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

     

       
6
       
 
       
  updateMoonlight(): Promise<void>;

     

       
7
       
 
       


     

       
8
       
-
       
  fetchRepositories(

     

       
9
       
-
       
    repos: string[]

     

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

     

       
11
       
-
       
  installExtension(

     

       
12
       
-
       
    manifest: RepositoryManifest,

     

       
13
       
-
       
    url: string,

     

       
14
       
-
       
    repo: string

     

       
15
       
-
       
  ): Promise<void>;

     

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

     

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

     

       
18
       
 
       
};

     

···

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

     

       
6
       
 
       
  updateMoonlight(): Promise<void>;

     

       
7
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
12
       
 
       
};

     

···

       
12
       
 
       


     

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

     

       
14
       
 
       


     

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

     

       
16
       
-
       
  .exports.Z;

     

       
17
       
 
       


     

       
18
       
 
       
const notice = {

     

       
19
       
 
       
  stores: [MoonbaseSettingsStore],

     

       
20
       
 
       
  element: () => {

     

       
21
       
 
       
    // Require it here because lazy loading SUX

     

       
22
       
-
       
    const SettingsNotice = spacepack.findByCode(

     

       
23
       
-
       
      "onSaveButtonColor",

     

       
24
       
-
       
      "FocusRingScope"

     

       
25
       
-
       
    )[0].exports.Z;

     

       
26
       
 
       
    return (

     

       
27
       
 
       
      <SettingsNotice

     

       
28
       
 
       
        submitting={MoonbaseSettingsStore.submitting}

     
···

       
37
       
 
       
  }

     

       
38
       
 
       
};

     

       
39
       
 
       


     

       
40
       
-
       
function addSection(

     

       
41
       
-
       
  id: string,

     

       
42
       
-
       
  name: string,

     

       
43
       
-
       
  element: React.FunctionComponent

     

       
44
       
-
       
) {

     

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

     

       
46
       
 
       
}

     

       
47
       
 
       


     
···

       
53
       
 
       


     

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

     

       
55
       
 
       
  return (

     

       
56
       
-
       
    <Text

     

       
57
       
-
       
      variant="heading-lg/semibold"

     

       
58
       
-
       
      tag="h2"

     

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

     

       
60
       
-
       
    >

     

       
61
       
 
       
      {crumb.label}

     

       
62
       
 
       
    </Text>

     

       
63
       
 
       
  );

     

       
64
       
 
       
}

     

       
65
       
 
       


     

       
66
       
-
       
if (

     

       
67
       
-
       
  MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       
68
       
-
       
    "moonbase",

     

       
69
       
-
       
    "sections",

     

       
70
       
-
       
    false

     

       
71
       
-
       
  )

     

       
72
       
-
       
) {

     

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

     

       
74
       
 
       


     

       
75
       
 
       
  for (const page of pages) {

     
···

       
102
       
 
       
  settings.addSectionMenuItems(

     

       
103
       
 
       
    "moonbase",

     

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

     

       
105
       
-
       
      <MenuItem

     

       
106
       
-
       
        key={page.id}

     

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

     

       
108
       
-
       
        label={page.name}

     

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

     

       
110
       
-
       
      />

     

       
111
       
 
       
    ))

     

       
112
       
 
       
  );

     

       
113
       
 
       
}

     

···

       
12
       
 
       


     

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

     

       
14
       
 
       


     

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

     

       
0
       
 
       

     

       
16
       
 
       


     

       
17
       
 
       
const notice = {

     

       
18
       
 
       
  stores: [MoonbaseSettingsStore],

     

       
19
       
 
       
  element: () => {

     

       
20
       
 
       
    // Require it here because lazy loading SUX

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
22
       
 
       
    return (

     

       
23
       
 
       
      <SettingsNotice

     

       
24
       
 
       
        submitting={MoonbaseSettingsStore.submitting}

     
···

       
33
       
 
       
  }

     

       
34
       
 
       
};

     

       
35
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
38
       
 
       
}

     

       
39
       
 
       


     
···

       
45
       
 
       


     

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

     

       
47
       
 
       
  return (

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
      {crumb.label}

     

       
50
       
 
       
    </Text>

     

       
51
       
 
       
  );

     

       
52
       
 
       
}

     

       
53
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
56
       
 
       


     

       
57
       
 
       
  for (const page of pages) {

     
···

       
84
       
 
       
  settings.addSectionMenuItems(

     

       
85
       
 
       
    "moonbase",

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
88
       
 
       
    ))

     

       
89
       
 
       
  );

     

       
90
       
 
       
}

     

···

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

     

       
2
       
-
       
import {

     

       
3
       
-
       
  ExtensionState,

     

       
4
       
-
       
  MoonbaseExtension,

     

       
5
       
-
       
  MoonbaseNatives,

     

       
6
       
-
       
  RepositoryManifest

     

       
7
       
-
       
} from "../types";

     

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

     

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

     

       
10
       
 
       
import getNatives from "../native";

     

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

     

       
12
       
-
       
import {

     

       
13
       
-
       
  checkExtensionCompat,

     

       
14
       
-
       
  ExtensionCompat

     

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

     

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

     

       
17
       
 
       


     

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

     
···

       
24
       
 
       
  private origConfig: Config;

     

       
25
       
 
       
  private config: Config;

     

       
26
       
 
       
  private extensionIndex: number;

     

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

     

       
28
       
-
       
    {};

     

       
29
       
 
       


     

       
30
       
 
       
  modified: boolean;

     

       
31
       
 
       
  submitting: boolean;

     
···

       
64
       
 
       
      this.extensions[uniqueId] = {

     

       
65
       
 
       
        ...ext,

     

       
66
       
 
       
        uniqueId,

     

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

     

       
68
       
-
       
          ? ExtensionState.Enabled

     

       
69
       
-
       
          : ExtensionState.Disabled,

     

       
70
       
 
       
        compat: checkExtensionCompat(ext.manifest),

     

       
71
       
 
       
        hasUpdate: false

     

       
72
       
 
       
      };

     
···

       
90
       
 
       
              };

     

       
91
       
 
       


     

       
92
       
 
       
              // Don't present incompatible updates

     

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

     

       
94
       
-
       
                continue;

     

       
95
       
 
       


     

       
96
       
 
       
              const existing = this.getExisting(extensionData);

     

       
97
       
 
       
              if (existing != null) {

     
···

       
137
       
 
       
        this.emitChange();

     

       
138
       
 
       
      })

     

       
139
       
 
       
      .then(() => {

     

       
140
       
-
       
        this.shouldShowNotice =

     

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

     

       
142
       
 
       
        this.emitChange();

     

       
143
       
 
       
      });

     

       
144
       
 
       
  }

     

       
145
       
 
       


     

       
146
       
 
       
  private getExisting(ext: MoonbaseExtension) {

     

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

     

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

     

       
149
       
-
       
    );

     

       
150
       
 
       
  }

     

       
151
       
 
       


     

       
152
       
 
       
  private hasUpdate(ext: MoonbaseExtension) {

     

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

     

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

     

       
155
       
-
       
    );

     

       
156
       
 
       
    if (existing == null) return false;

     

       
157
       
 
       


     

       
158
       
-
       
    return (

     

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

     

       
160
       
-
       
      existing.state !== ExtensionState.NotDownloaded

     

       
161
       
-
       
    );

     

       
162
       
 
       
  }

     

       
163
       
 
       


     

       
164
       
 
       
  // Jank

     
···

       
181
       
 
       
  }

     

       
182
       
 
       


     

       
183
       
 
       
  getExtensionUniqueId(id: string) {

     

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

     

       
185
       
-
       
      ?.uniqueId;

     

       
186
       
 
       
  }

     

       
187
       
 
       


     

       
188
       
 
       
  getExtensionConflicting(uniqueId: number) {

     

       
189
       
 
       
    const ext = this.getExtension(uniqueId);

     

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

     

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

     

       
192
       
-
       
      (e) =>

     

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

     

       
194
       
-
       
        e.uniqueId !== uniqueId &&

     

       
195
       
-
       
        e.state !== ExtensionState.NotDownloaded

     

       
196
       
 
       
    );

     

       
197
       
 
       
  }

     

       
198
       
 
       


     
···

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

     

       
224
       
 
       
  }

     

       
225
       
 
       


     

       
226
       
-
       
  getExtensionConfigRaw<T>(

     

       
227
       
-
       
    id: string,

     

       
228
       
-
       
    key: string,

     

       
229
       
-
       
    defaultValue: T | undefined

     

       
230
       
-
       
  ): T | undefined {

     

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

     

       
232
       
 
       


     

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

     
···

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

     

       
300
       
 
       
      }

     

       
301
       
 
       


     

       
302
       
-
       
      if (update != null)

     

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

     

       
304
       
-
       
          update.updateManifest

     

       
305
       
-
       
        );

     

       
306
       
 
       


     

       
307
       
 
       
      delete this.updates[uniqueId];

     

       
308
       
 
       
    } catch (e) {

     
···

       
335
       
 
       


     

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

     

       
337
       
 
       
    for (const dep of missingDeps) {

     

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

     

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

     

       
340
       
-
       
      );

     

       
341
       
 
       


     

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

     

       
343
       
 
       
        const aRank = this.getRank(a);

     

       
344
       
 
       
        const bRank = this.getRank(b);

     

       
345
       
 
       
        if (aRank === bRank) {

     

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

     

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

     

       
348
       
-
       
            b.source.url!

     

       
349
       
-
       
          );

     

       
350
       
 
       
          return repoIndex - otherRepoIndex;

     

       
351
       
 
       
        } else {

     

       
352
       
 
       
          return bRank - aRank;

     
···

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

     

       
393
       
 
       
  }

     

       
394
       
 
       


     

       
395
       
-
       
  registerConfigComponent(

     

       
396
       
-
       
    ext: string,

     

       
397
       
-
       
    name: string,

     

       
398
       
-
       
    component: CustomComponent

     

       
399
       
-
       
  ) {

     

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

     

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

     

       
402
       
 
       
  }

     

···

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
5
       
 
       
import getNatives from "../native";

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
9
       
 
       


     

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

     
···

       
16
       
 
       
  private origConfig: Config;

     

       
17
       
 
       
  private config: Config;

     

       
18
       
 
       
  private extensionIndex: number;

     

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

     

       
0
       
 
       

     

       
20
       
 
       


     

       
21
       
 
       
  modified: boolean;

     

       
22
       
 
       
  submitting: boolean;

     
···

       
55
       
 
       
      this.extensions[uniqueId] = {

     

       
56
       
 
       
        ...ext,

     

       
57
       
 
       
        uniqueId,

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
59
       
 
       
        compat: checkExtensionCompat(ext.manifest),

     

       
60
       
 
       
        hasUpdate: false

     

       
61
       
 
       
      };

     
···

       
79
       
 
       
              };

     

       
80
       
 
       


     

       
81
       
 
       
              // Don't present incompatible updates

     

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

     

       
0
       
 
       

     

       
83
       
 
       


     

       
84
       
 
       
              const existing = this.getExisting(extensionData);

     

       
85
       
 
       
              if (existing != null) {

     
···

       
125
       
 
       
        this.emitChange();

     

       
126
       
 
       
      })

     

       
127
       
 
       
      .then(() => {

     

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

     

       
0
       
 
       

     

       
129
       
 
       
        this.emitChange();

     

       
130
       
 
       
      });

     

       
131
       
 
       
  }

     

       
132
       
 
       


     

       
133
       
 
       
  private getExisting(ext: MoonbaseExtension) {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
135
       
 
       
  }

     

       
136
       
 
       


     

       
137
       
 
       
  private hasUpdate(ext: MoonbaseExtension) {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
139
       
 
       
    if (existing == null) return false;

     

       
140
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
142
       
 
       
  }

     

       
143
       
 
       


     

       
144
       
 
       
  // Jank

     
···

       
161
       
 
       
  }

     

       
162
       
 
       


     

       
163
       
 
       
  getExtensionUniqueId(id: string) {

     

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

     

       
0
       
 
       

     

       
165
       
 
       
  }

     

       
166
       
 
       


     

       
167
       
 
       
  getExtensionConflicting(uniqueId: number) {

     

       
168
       
 
       
    const ext = this.getExtension(uniqueId);

     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
172
       
 
       
    );

     

       
173
       
 
       
  }

     

       
174
       
 
       


     
···

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

     

       
200
       
 
       
  }

     

       
201
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
204
       
 
       


     

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

     
···

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

     

       
272
       
 
       
      }

     

       
273
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
275
       
 
       


     

       
276
       
 
       
      delete this.updates[uniqueId];

     

       
277
       
 
       
    } catch (e) {

     
···

       
304
       
 
       


     

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

     

       
306
       
 
       
    for (const dep of missingDeps) {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
308
       
 
       


     

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

     

       
310
       
 
       
        const aRank = this.getRank(a);

     

       
311
       
 
       
        const bRank = this.getRank(b);

     

       
312
       
 
       
        if (aRank === bRank) {

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
315
       
 
       
          return repoIndex - otherRepoIndex;

     

       
316
       
 
       
        } else {

     

       
317
       
 
       
          return bRank - aRank;

     
···

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

     

       
358
       
 
       
  }

     

       
359
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
363
       
 
       
  }

     

···

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

     

       
2
       
 
       


     

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

     

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

     

       
5
       
-
       
) as string[];

     

       
6
       
 
       


     

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

     

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

     
···

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

     

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

     

       
34
       
 
       
  )

     

       
35
       
-
       
  .then(

     

       
36
       
-
       
    () =>

     

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

     

       
38
       
-
       
        .exports)

     

       
39
       
-
       
  );

     

       
40
       
 
       


     

       
41
       
 
       
// FIXME: type component keys

     

       
42
       
 
       
const { CircleXIcon } = Components;

     
···

       
46
       
 
       
    <div className={RemoveButtonClasses.removeButtonContainer}>

     

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

     

       
48
       
 
       
        {(props: any) => (

     

       
49
       
-
       
          <Clickable

     

       
50
       
-
       
            {...props}

     

       
51
       
-
       
            className={RemoveButtonClasses.removeButton}

     

       
52
       
-
       
            onClick={onClick}

     

       
53
       
-
       
          >

     

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

     

       
55
       
 
       
          </Clickable>

     

       
56
       
 
       
        )}

     
···

       
59
       
 
       
  );

     

       
60
       
 
       
}

     

       
61
       
 
       


     

       
62
       
-
       
function ArrayFormItem({

     

       
63
       
-
       
  config

     

       
64
       
-
       
}: {

     

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

     

       
66
       
-
       
}) {

     

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

     

       
68
       
 
       
  return (

     

       
69
       
 
       
    <Flex

     
···

       
123
       
 
       
    <>

     

       
124
       
 
       
      <FormSwitch

     

       
125
       
 
       
        className={Margins.marginTop20}

     

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

     

       
127
       
-
       
          "moonbase",

     

       
128
       
-
       
          "updateChecking",

     

       
129
       
-
       
          true

     

       
130
       
-
       
        )}

     

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

     

       
132
       
-
       
          MoonbaseSettingsStore.setExtensionConfig(

     

       
133
       
-
       
            "moonbase",

     

       
134
       
-
       
            "updateChecking",

     

       
135
       
-
       
            value

     

       
136
       
-
       
          );

     

       
137
       
 
       
        }}

     

       
138
       
 
       
        note="Checks for updates to moonlight"

     

       
139
       
 
       
      >

     

       
140
       
 
       
        Automatic update checking

     

       
141
       
 
       
      </FormSwitch>

     

       
142
       
 
       
      <FormItem title="Repositories">

     

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

     

       
144
       
-
       
          A list of remote repositories to display extensions from

     

       
145
       
-
       
        </FormText>

     

       
146
       
 
       
        <ArrayFormItem config="repositories" />

     

       
147
       
 
       
      </FormItem>

     

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

     
···

       
172
       
 
       
            value: o.toLowerCase(),

     

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

     

       
174
       
 
       
          }))}

     

       
175
       
-
       
          onChange={(v) =>

     

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

     

       
177
       
-
       
          }

     

       
178
       
 
       
        />

     

       
179
       
 
       
      </FormItem>

     

       
180
       
 
       
    </>

     

···

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

     

       
2
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4
       
 
       


     

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

     

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

     
···

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

     

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

     

       
32
       
 
       
  )

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
34
       
 
       


     

       
35
       
 
       
// FIXME: type component keys

     

       
36
       
 
       
const { CircleXIcon } = Components;

     
···

       
40
       
 
       
    <div className={RemoveButtonClasses.removeButtonContainer}>

     

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

     

       
42
       
 
       
        {(props: any) => (

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
45
       
 
       
          </Clickable>

     

       
46
       
 
       
        )}

     
···

       
49
       
 
       
  );

     

       
50
       
 
       
}

     

       
51
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
54
       
 
       
  return (

     

       
55
       
 
       
    <Flex

     
···

       
109
       
 
       
    <>

     

       
110
       
 
       
      <FormSwitch

     

       
111
       
 
       
        className={Margins.marginTop20}

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
115
       
 
       
        }}

     

       
116
       
 
       
        note="Checks for updates to moonlight"

     

       
117
       
 
       
      >

     

       
118
       
 
       
        Automatic update checking

     

       
119
       
 
       
      </FormSwitch>

     

       
120
       
 
       
      <FormItem title="Repositories">

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
122
       
 
       
        <ArrayFormItem config="repositories" />

     

       
123
       
 
       
      </FormItem>

     

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

     
···

       
148
       
 
       
            value: o.toLowerCase(),

     

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

     

       
150
       
 
       
          }))}

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
152
       
 
       
        />

     

       
153
       
 
       
      </FormItem>

     

       
154
       
 
       
    </>

     

···

       
22
       
 
       


     

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

     

       
24
       
 
       


     

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

     

       
26
       
-
       
  Components;

     

       
27
       
 
       


     

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

     

       
29
       
-
       
const TabBarClasses = spacepack.findByExports(

     

       
30
       
-
       
  "tabBar",

     

       
31
       
-
       
  "tabBarItem",

     

       
32
       
-
       
  "headerContentWrapper"

     

       
33
       
-
       
)[0].exports;

     

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

     

       
35
       
-
       
  .exports;

     

       
36
       
 
       


     

       
37
       
-
       
const BuildOverrideClasses = spacepack.findByExports(

     

       
38
       
-
       
  "disabledButtonOverride"

     

       
39
       
-
       
)[0].exports;

     

       
40
       
 
       


     

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

     

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

     
···

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

     

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

     

       
50
       
 
       


     

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

     

       
52
       
-
       
    [MoonbaseSettingsStore],

     

       
53
       
-
       
    () => {

     

       
54
       
-
       
      return {

     

       
55
       
-
       
        ext: MoonbaseSettingsStore.getExtension(uniqueId),

     

       
56
       
-
       
        enabled: MoonbaseSettingsStore.getExtensionEnabled(uniqueId),

     

       
57
       
-
       
        busy: MoonbaseSettingsStore.busy,

     

       
58
       
-
       
        update: MoonbaseSettingsStore.getExtensionUpdate(uniqueId),

     

       
59
       
-
       
        conflicting: MoonbaseSettingsStore.getExtensionConflicting(uniqueId)

     

       
60
       
-
       
      };

     

       
61
       
-
       
    }

     

       
62
       
-
       
  );

     

       
63
       
 
       


     

       
64
       
 
       
  // Why it work like that :sob:

     

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

     
···

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

     

       
73
       
 
       
    Object.keys(MoonbaseSettingsStore.extensions)

     

       
74
       
 
       
      .filter((uniqueId) => {

     

       
75
       
-
       
        const potentialDependant = MoonbaseSettingsStore.getExtension(

     

       
76
       
-
       
          parseInt(uniqueId)

     

       
77
       
-
       
        );

     

       
78
       
 
       


     

       
79
       
 
       
        return (

     

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

     
···

       
90
       
 
       
      <div className={IntegrationCard.cardHeader}>

     

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

     

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

     

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

     

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

     

       
95
       
-
       
            </Text>

     

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

     

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

     

       
98
       
-
       
                {(props: any) => (

     

       
99
       
-
       
                  <BeakerIcon

     

       
100
       
-
       
                    {...props}

     

       
101
       
-
       
                    class={BuildOverrideClasses.infoIcon}

     

       
102
       
-
       
                    size="xs"

     

       
103
       
-
       
                  />

     

       
104
       
-
       
                )}

     

       
105
       
 
       
              </Tooltip>

     

       
106
       
 
       
            )}

     

       
107
       
 
       
          </Flex>

     

       
108
       
 
       


     

       
109
       
-
       
          {tagline != null && (

     

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

     

       
111
       
-
       
          )}

     

       
112
       
 
       
        </Flex>

     

       
113
       
 
       


     

       
114
       
-
       
        <Flex

     

       
115
       
-
       
          direction={Flex.Direction.HORIZONTAL}

     

       
116
       
-
       
          align={Flex.Align.END}

     

       
117
       
-
       
          justify={Flex.Justify.END}

     

       
118
       
-
       
        >

     

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

     

       
120
       
-
       
            <Tooltip

     

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

     

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

     

       
123
       
-
       
            >

     

       
124
       
 
       
              {(props: any) => (

     

       
125
       
 
       
                <Button

     

       
126
       
 
       
                  {...props}

     

       
127
       
 
       
                  color={Button.Colors.BRAND}

     

       
128
       
 
       
                  submitting={busy}

     

       
129
       
-
       
                  disabled={

     

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

     

       
131
       
-
       
                  }

     

       
132
       
 
       
                  onClick={async () => {

     

       
133
       
 
       
                    await installWithDependencyPopup(uniqueId);

     

       
134
       
 
       
                  }}

     
···

       
168
       
 
       


     

       
169
       
 
       
              {restartNeeded && (

     

       
170
       
 
       
                <PanelButton

     

       
171
       
-
       
                  icon={() => (

     

       
172
       
-
       
                    <CircleWarningIcon

     

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

     

       
174
       
-
       
                    />

     

       
175
       
-
       
                  )}

     

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

     

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

     

       
178
       
 
       
                />

     

       
179
       
 
       
              )}

     

       
180
       
 
       


     

       
181
       
 
       
              <FormSwitch

     

       
182
       
-
       
                value={

     

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

     

       
184
       
-
       
                  (enabled || implicitlyEnabled)

     

       
185
       
-
       
                }

     

       
186
       
-
       
                disabled={

     

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

     

       
188
       
-
       
                }

     

       
189
       
 
       
                hideBorder={true}

     

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

     

       
191
       
 
       
                tooltipNote={

     
···

       
194
       
 
       
                    : implicitlyEnabled

     

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

     

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

     

       
197
       
-
       
                        }: ${enabledDependants

     

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

     

       
199
       
-
       
                          .join(", ")}`

     

       
200
       
 
       
                      : undefined

     

       
201
       
 
       
                }

     

       
202
       
 
       
                onChange={() => {

     
···

       
220
       
 
       
              padding: "0 20px"

     

       
221
       
 
       
            }}

     

       
222
       
 
       
          >

     

       
223
       
-
       
            <TabBar.Item

     

       
224
       
-
       
              className={TabBarClasses.tabBarItem}

     

       
225
       
-
       
              id={ExtensionPage.Info}

     

       
226
       
-
       
            >

     

       
227
       
 
       
              Info

     

       
228
       
 
       
            </TabBar.Item>

     

       
229
       
 
       


     

       
230
       
 
       
            {description != null && (

     

       
231
       
-
       
              <TabBar.Item

     

       
232
       
-
       
                className={TabBarClasses.tabBarItem}

     

       
233
       
-
       
                id={ExtensionPage.Description}

     

       
234
       
-
       
              >

     

       
235
       
 
       
                Description

     

       
236
       
 
       
              </TabBar.Item>

     

       
237
       
 
       
            )}

     

       
238
       
 
       


     

       
239
       
 
       
            {settings != null && (

     

       
240
       
-
       
              <TabBar.Item

     

       
241
       
-
       
                className={TabBarClasses.tabBarItem}

     

       
242
       
-
       
                id={ExtensionPage.Settings}

     

       
243
       
-
       
              >

     

       
244
       
 
       
                Settings

     

       
245
       
 
       
              </TabBar.Item>

     

       
246
       
 
       
            )}

     
···

       
256
       
 
       
        >

     

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

     

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

     

       
259
       
-
       
            <Text

     

       
260
       
-
       
              variant="text-md/normal"

     

       
261
       
-
       
              class={MarkupClasses.markup}

     

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

     

       
263
       
-
       
            >

     

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

     

       
265
       
 
       
                allowHeading: true,

     

       
266
       
 
       
                allowLinks: true,

     

···

       
22
       
 
       


     

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

     

       
24
       
 
       


     

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

     

       
0
       
 
       

     

       
26
       
 
       


     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
30
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       


     

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

     

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

     
···

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

     

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

     

       
42
       
 
       


     

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

     

       
44
       
+
       
    return {

     

       
45
       
+
       
      ext: MoonbaseSettingsStore.getExtension(uniqueId),

     

       
46
       
+
       
      enabled: MoonbaseSettingsStore.getExtensionEnabled(uniqueId),

     

       
47
       
+
       
      busy: MoonbaseSettingsStore.busy,

     

       
48
       
+
       
      update: MoonbaseSettingsStore.getExtensionUpdate(uniqueId),

     

       
49
       
+
       
      conflicting: MoonbaseSettingsStore.getExtensionConflicting(uniqueId)

     

       
50
       
+
       
    };

     

       
51
       
+
       
  });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
52
       
 
       


     

       
53
       
 
       
  // Why it work like that :sob:

     

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

     
···

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

     

       
62
       
 
       
    Object.keys(MoonbaseSettingsStore.extensions)

     

       
63
       
 
       
      .filter((uniqueId) => {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
65
       
 
       


     

       
66
       
 
       
        return (

     

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

     
···

       
77
       
 
       
      <div className={IntegrationCard.cardHeader}>

     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
84
       
 
       
              </Tooltip>

     

       
85
       
 
       
            )}

     

       
86
       
 
       
          </Flex>

     

       
87
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
89
       
 
       
        </Flex>

     

       
90
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
94
       
 
       
              {(props: any) => (

     

       
95
       
 
       
                <Button

     

       
96
       
 
       
                  {...props}

     

       
97
       
 
       
                  color={Button.Colors.BRAND}

     

       
98
       
 
       
                  submitting={busy}

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
100
       
 
       
                  onClick={async () => {

     

       
101
       
 
       
                    await installWithDependencyPopup(uniqueId);

     

       
102
       
 
       
                  }}

     
···

       
136
       
 
       


     

       
137
       
 
       
              {restartNeeded && (

     

       
138
       
 
       
                <PanelButton

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
142
       
 
       
                />

     

       
143
       
 
       
              )}

     

       
144
       
 
       


     

       
145
       
 
       
              <FormSwitch

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
148
       
 
       
                hideBorder={true}

     

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

     

       
150
       
 
       
                tooltipNote={

     
···

       
153
       
 
       
                    : implicitlyEnabled

     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
157
       
 
       
                      : undefined

     

       
158
       
 
       
                }

     

       
159
       
 
       
                onChange={() => {

     
···

       
177
       
 
       
              padding: "0 20px"

     

       
178
       
 
       
            }}

     

       
179
       
 
       
          >

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
181
       
 
       
              Info

     

       
182
       
 
       
            </TabBar.Item>

     

       
183
       
 
       


     

       
184
       
 
       
            {description != null && (

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
186
       
 
       
                Description

     

       
187
       
 
       
              </TabBar.Item>

     

       
188
       
 
       
            )}

     

       
189
       
 
       


     

       
190
       
 
       
            {settings != null && (

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
192
       
 
       
                Settings

     

       
193
       
 
       
              </TabBar.Item>

     

       
194
       
 
       
            )}

     
···

       
204
       
 
       
        >

     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
209
       
 
       
                allowHeading: true,

     

       
210
       
 
       
                allowLinks: true,