commit f524648b0b5c06db95fd3cefe78f7c4d9379865a · notnite.com/moonlight

+2

.github/workflows/nightly.yml

···

       31
       31
        
             - name: Build moonlight

     

       32
       32
        
               env:

     

       33
       33
        
                 NODE_ENV: production

     

       34
       34
       +
                 MOONLIGHT_BRANCH: nightly

     

       35
       35
       +
                 MOONLIGHT_VERSION: ${{ github.sha }}

     

       34
       36
        
               run: pnpm run build

     

       35
       37
        
       

     

       36
       38
        
             - name: Write ref/commit to file

+2

.github/workflows/release.yml

···

       29
       29
        
             - name: Build moonlight

     

       30
       30
        
               env:

     

       31
       31
        
                 NODE_ENV: production

     

       32
       32
       +
                 MOONLIGHT_BRANCH: stable

     

       33
       33
       +
                 MOONLIGHT_VERSION: ${{ github.ref_name }}

     

       32
       34
        
               run: pnpm run build

     

       33
       35
        
             - name: Create archive

     

       34
       36
        
               run: |

+11 -3

build.mjs

···

       16
       16
        
       const browser = process.argv.includes("--browser");

     

       17
       17
        
       const mv2 = process.argv.includes("--mv2");

     

       18
       18
        
       

     

       19
       19
       +
       const buildBranch = process.env.MOONLIGHT_BRANCH ?? "dev";

     

       20
       20
       +
       const buildVersion = process.env.MOONLIGHT_VERSION ?? "dev";

     

       21
       21
       +
       

     

       19
       22
        
       const external = [

     

       20
       23
        
         "electron",

     

       21
       24
        
         "fs",

     
···

       96
       99
        
       

     

       97
       100
        
         const define = {

     

       98
       101
        
           MOONLIGHT_ENV: `"${name}"`,

     

       99
       99
       -
           MOONLIGHT_PROD: prod.toString()

     

       102
       102
       +
           MOONLIGHT_PROD: prod.toString(),

     

       103
       103
       +
           MOONLIGHT_BRANCH: `"${buildBranch}"`,

     

       104
       104
       +
           MOONLIGHT_VERSION: `"${buildVersion}"`

     

       100
       105
        
         };

     

       101
       106
        
       

     

       102
       107
        
         for (const iterName of [

     
···

       153
       158
        
           entryPoints: [entry],

     

       154
       159
        
           outfile,

     

       155
       160
        
       

     

       156
       156
       -
           format: "cjs",

     

       161
       161
       +
           format: "iife",

     

       162
       162
       +
           globalName: "module.exports",

     

       163
       163
       +
       

     

       157
       164
        
           platform: ["web-preload", "browser"].includes(name) ? "browser" : "node",

     

       158
       165
        
       

     

       159
       166
        
           treeShaking: true,

     
···

       256
       263
        
           entryPoints,

     

       257
       264
        
           outdir,

     

       258
       265
        
       

     

       259
       259
       -
           format: "cjs",

     

       266
       266
       +
           format: "iife",

     

       267
       267
       +
           globalName: "module.exports",

     

       260
       268
        
           platform: "node",

     

       261
       269
        
       

     

       262
       270
        
           treeShaking: true,

+3 -86

flake.nix

···

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         outputs = { self, nixpkgs, flake-utils, pnpm2nix }:

     

       11
       11
       -
           let

     

       12
       12
       -
             mkMoonlight = { pkgs, mkPnpmPackage }:

     

       13
       13
       -
               mkPnpmPackage rec {

     

       14
       14
       -
                 workspace = ./.;

     

       15
       15
       -
                 src = ./.;

     

       16
       16
       -
                 components = [

     

       17
       17
       -
                   "packages/core"

     

       18
       18
       -
                   "packages/core-extensions"

     

       19
       19
       -
                   "packages/injector"

     

       20
       20
       -
                   "packages/node-preload"

     

       21
       21
       -
                   "packages/types"

     

       22
       22
       -
                   "packages/web-preload"

     

       23
       23
       -
                 ];

     

       24
       24
       -
                 distDirs = [ "dist" ];

     

       25
       25
       -
       

     

       26
       26
       -
                 copyNodeModules = true;

     

       27
       27
       -
                 buildPhase = "pnpm run build";

     

       28
       28
       -
                 installPhase = "cp -r dist $out";

     

       29
       29
       -
       

     

       30
       30
       -
                 meta = with pkgs.lib; {

     

       31
       31
       -
                   description = "Yet another Discord mod";

     

       32
       32
       -
                   homepage = "https://moonlight-mod.github.io/";

     

       33
       33
       -
                   license = licenses.lgpl3;

     

       34
       34
       -
                   maintainers = with maintainers; [ notnite ];

     

       35
       35
       -
                 };

     

       36
       36
       -
               };

     

       37
       37
       -
       

     

       38
       38
       -
             nameTable = {

     

       39
       39
       -
               discord = "Discord";

     

       40
       40
       -
               discord-ptb = "DiscordPTB";

     

       41
       41
       -
               discord-canary = "DiscordCanary";

     

       42
       42
       -
               discord-development = "DiscordDevelopment";

     

       43
       43
       -
             };

     

       44
       44
       -
       

     

       45
       45
       -
             darwinNameTable = {

     

       46
       46
       -
               discord = "Discord";

     

       47
       47
       -
               discord-ptb = "Discord PTB";

     

       48
       48
       -
               discord-canary = "Discord Canary";

     

       49
       49
       -
               discord-development = "Discord Development";

     

       50
       50
       -
             };

     

       51
       51
       -
       

     

       52
       52
       -
             mkOverride = prev: moonlight: name:

     

       53
       53
       -
               let discord = prev.${name};

     

       54
       54
       -
               in discord.overrideAttrs (old: {

     

       55
       55
       -
                 installPhase = let

     

       56
       56
       -
                   folderName = nameTable.${name};

     

       57
       57
       -
                   darwinFolderName = darwinNameTable.${name};

     

       58
       58
       -
       

     

       59
       59
       -
                   injected = ''

     

       60
       60
       -
                     require("${moonlight}/injector").inject(

     

       61
       61
       -
                       require("path").join(__dirname, "../_app.asar")

     

       62
       62
       -
                     );

     

       63
       63
       -
                   '';

     

       64
       64
       -
       

     

       65
       65
       -
                   packageJson = ''

     

       66
       66
       -
                     {"name":"discord","main":"./injector.js","private":true}

     

       67
       67
       -
                   '';

     

       68
       68
       -
       

     

       69
       69
       -
                 in old.installPhase + "\n" + ''

     

       70
       70
       -
                   resources="$out/opt/${folderName}/resources"

     

       71
       71
       -
                   if [ ! -d "$resources" ]; then

     

       72
       72
       -
                     resources="$out/Applications/${darwinFolderName}.app/Contents/Resources"

     

       73
       73
       -
                   fi

     

       74
       74
       -
       

     

       75
       75
       -
                   mv "$resources/app.asar" "$resources/_app.asar"

     

       76
       76
       -
                   mkdir -p "$resources/app"

     

       77
       77
       -
       

     

       78
       78
       -
                   cat > "$resources/app/injector.js" <<EOF

     

       79
       79
       -
                   ${injected}

     

       80
       80
       -
                   EOF

     

       81
       81
       -
       

     

       82
       82
       -
                   echo '${packageJson}' > "$resources/app/package.json"

     

       83
       83
       -
                 '';

     

       84
       84
       -
               });

     

       85
       85
       -
       

     

       86
       86
       -
             overlay = final: prev: rec {

     

       87
       87
       -
               moonlight-mod = mkMoonlight {

     

       88
       88
       -
                 pkgs = final;

     

       89
       89
       -
                 mkPnpmPackage = pnpm2nix.packages.${final.system}.mkPnpmPackage;

     

       90
       90
       -
               };

     

       91
       91
       -
               discord = mkOverride prev moonlight-mod "discord";

     

       92
       92
       -
               discord-ptb = mkOverride prev moonlight-mod "discord-ptb";

     

       93
       93
       -
               discord-canary = mkOverride prev moonlight-mod "discord-canary";

     

       94
       94
       -
               discord-development =

     

       95
       95
       -
                 mkOverride prev moonlight-mod "discord-development";

     

       96
       96
       -
             };

     

       11
       11
       +
           let overlay = import ./nix/overlay.nix { inherit pnpm2nix; };

     

       97
       12
        
           in flake-utils.lib.eachDefaultSystem (system:

     

       98
       13
        
             let

     

       99
       14
        
               pkgs = import nixpkgs {

     
···

       102
       17
        
                 overlays = [ overlay ];

     

       103
       18
        
               };

     

       104
       19
        
             in {

     

       20
       20
       +
               # Don't use these unless you're testing things

     

       105
       21
        
               packages.default = pkgs.moonlight-mod;

     

       106
       22
        
               packages.moonlight-mod = pkgs.moonlight-mod;

     

       107
       23
        
       

     
···

       111
       27
        
               packages.discord-development = pkgs.discord-development;

     

       112
       28
        
             }) // {

     

       113
       29
        
               overlays.default = overlay;

     

       30
       30
       +
               homeModules.default = ./nix/home-manager.nix;

     

       114
       31
        
             };

     

       115
       32
        
       }

+28

nix/default.nix

···

       1
       1
       +
       { pkgs, mkPnpmPackage }:

     

       2
       2
       +
       

     

       3
       3
       +
       mkPnpmPackage rec {

     

       4
       4
       +
         workspace = ./..;

     

       5
       5
       +
         src = ./..;

     

       6
       6
       +
       

     

       7
       7
       +
         # Work around a bug with how it expects dist

     

       8
       8
       +
         components = [

     

       9
       9
       +
           "packages/core"

     

       10
       10
       +
           "packages/core-extensions"

     

       11
       11
       +
           "packages/injector"

     

       12
       12
       +
           "packages/node-preload"

     

       13
       13
       +
           "packages/types"

     

       14
       14
       +
           "packages/web-preload"

     

       15
       15
       +
         ];

     

       16
       16
       +
         distDirs = [ "dist" ];

     

       17
       17
       +
       

     

       18
       18
       +
         copyNodeModules = true;

     

       19
       19
       +
         buildPhase = "pnpm run build";

     

       20
       20
       +
         installPhase = "cp -r dist $out";

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with pkgs.lib; {

     

       23
       23
       +
           description = "Yet another Discord mod";

     

       24
       24
       +
           homepage = "https://moonlight-mod.github.io/";

     

       25
       25
       +
           license = licenses.lgpl3;

     

       26
       26
       +
           maintainers = with maintainers; [ notnite ];

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+56

nix/home-manager.nix

···

       1
       1
       +
       { config, lib, pkgs, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       let cfg = config.programs.moonlight-mod;

     

       4
       4
       +
       in {

     

       5
       5
       +
         options.programs.moonlight-mod = {

     

       6
       6
       +
           enable = lib.mkEnableOption "Yet another Discord mod";

     

       7
       7
       +
       

     

       8
       8
       +
           configs = let

     

       9
       9
       +
             # TODO: type this

     

       10
       10
       +
             type = lib.types.nullOr (lib.types.attrs);

     

       11
       11
       +
             default = null;

     

       12
       12
       +
           in {

     

       13
       13
       +
             stable = lib.mkOption {

     

       14
       14
       +
               inherit type default;

     

       15
       15
       +
               description = "Configuration for Discord Stable";

     

       16
       16
       +
             };

     

       17
       17
       +
       

     

       18
       18
       +
             ptb = lib.mkOption {

     

       19
       19
       +
               inherit type default;

     

       20
       20
       +
               description = "Configuration for Discord PTB";

     

       21
       21
       +
             };

     

       22
       22
       +
       

     

       23
       23
       +
             canary = lib.mkOption {

     

       24
       24
       +
               inherit type default;

     

       25
       25
       +
               description = "Configuration for Discord Canary";

     

       26
       26
       +
             };

     

       27
       27
       +
       

     

       28
       28
       +
             development = lib.mkOption {

     

       29
       29
       +
               inherit type default;

     

       30
       30
       +
               description = "Configuration for Discord Development";

     

       31
       31
       +
             };

     

       32
       32
       +
           };

     

       33
       33
       +
         };

     

       34
       34
       +
       

     

       35
       35
       +
         config = lib.mkIf cfg.enable {

     

       36
       36
       +
           xdg.configFile."moonlight-mod/stable.json" =

     

       37
       37
       +
             lib.mkIf (cfg.configs.stable != null) {

     

       38
       38
       +
               text = builtins.toJSON cfg.configs.stable;

     

       39
       39
       +
             };

     

       40
       40
       +
       

     

       41
       41
       +
           xdg.configFile."moonlight-mod/ptb.json" =

     

       42
       42
       +
             lib.mkIf (cfg.configs.ptb != null) {

     

       43
       43
       +
               text = builtins.toJSON cfg.configs.ptb;

     

       44
       44
       +
             };

     

       45
       45
       +
       

     

       46
       46
       +
           xdg.configFile."moonlight-mod/canary.json" =

     

       47
       47
       +
             lib.mkIf (cfg.configs.canary != null) {

     

       48
       48
       +
               text = builtins.toJSON cfg.configs.canary;

     

       49
       49
       +
             };

     

       50
       50
       +
       

     

       51
       51
       +
           xdg.configFile."moonlight-mod/development.json" =

     

       52
       52
       +
             lib.mkIf (cfg.configs.development != null) {

     

       53
       53
       +
               text = builtins.toJSON cfg.configs.development;

     

       54
       54
       +
             };

     

       55
       55
       +
         };

     

       56
       56
       +
       }

+60

nix/overlay.nix

···

       1
       1
       +
       { pnpm2nix }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         nameTable = {

     

       5
       5
       +
           discord = "Discord";

     

       6
       6
       +
           discord-ptb = "DiscordPTB";

     

       7
       7
       +
           discord-canary = "DiscordCanary";

     

       8
       8
       +
           discord-development = "DiscordDevelopment";

     

       9
       9
       +
         };

     

       10
       10
       +
       

     

       11
       11
       +
         darwinNameTable = {

     

       12
       12
       +
           discord = "Discord";

     

       13
       13
       +
           discord-ptb = "Discord PTB";

     

       14
       14
       +
           discord-canary = "Discord Canary";

     

       15
       15
       +
           discord-development = "Discord Development";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         mkOverride = prev: moonlight: name:

     

       19
       19
       +
           let discord = prev.${name};

     

       20
       20
       +
           in discord.overrideAttrs (old: {

     

       21
       21
       +
             installPhase = let

     

       22
       22
       +
               folderName = nameTable.${name};

     

       23
       23
       +
               darwinFolderName = darwinNameTable.${name};

     

       24
       24
       +
       

     

       25
       25
       +
               injected = ''

     

       26
       26
       +
                 require("${moonlight}/injector").inject(

     

       27
       27
       +
                   require("path").join(__dirname, "../_app.asar")

     

       28
       28
       +
                 );

     

       29
       29
       +
               '';

     

       30
       30
       +
       

     

       31
       31
       +
               packageJson = ''

     

       32
       32
       +
                 {"name":"discord","main":"./injector.js","private":true}

     

       33
       33
       +
               '';

     

       34
       34
       +
       

     

       35
       35
       +
             in old.installPhase + "\n" + ''

     

       36
       36
       +
               resources="$out/opt/${folderName}/resources"

     

       37
       37
       +
               if [ ! -d "$resources" ]; then

     

       38
       38
       +
                 resources="$out/Applications/${darwinFolderName}.app/Contents/Resources"

     

       39
       39
       +
               fi

     

       40
       40
       +
       

     

       41
       41
       +
               mv "$resources/app.asar" "$resources/_app.asar"

     

       42
       42
       +
               mkdir -p "$resources/app"

     

       43
       43
       +
       

     

       44
       44
       +
               cat > "$resources/app/injector.js" <<EOF

     

       45
       45
       +
               ${injected}

     

       46
       46
       +
               EOF

     

       47
       47
       +
       

     

       48
       48
       +
               echo '${packageJson}' > "$resources/app/package.json"

     

       49
       49
       +
             '';

     

       50
       50
       +
           });

     

       51
       51
       +
       in final: prev: rec {

     

       52
       52
       +
         moonlight-mod = final.callPackage ./default.nix {

     

       53
       53
       +
           pkgs = final;

     

       54
       54
       +
           mkPnpmPackage = pnpm2nix.packages.${final.system}.mkPnpmPackage;

     

       55
       55
       +
         };

     

       56
       56
       +
         discord = mkOverride prev moonlight-mod "discord";

     

       57
       57
       +
         discord-ptb = mkOverride prev moonlight-mod "discord-ptb";

     

       58
       58
       +
         discord-canary = mkOverride prev moonlight-mod "discord-canary";

     

       59
       59
       +
         discord-development = mkOverride prev moonlight-mod "discord-development";

     

       60
       60
       +
       }

+1

packages/browser/manifest.json

···

       11
       11
        
         ],

     

       12
       12
        
         "host_permissions": [

     

       13
       13
        
           "https://moonlight-mod.github.io/*",

     

       14
       14
       +
           "https://api.github.com/*",

     

       14
       15
        
           "https://*.discord.com/*"

     

       15
       16
        
         ],

     

       16
       17
        
         "content_scripts": [

+2

packages/browser/manifestv2.json

···

       9
       9
        
           "scripting",

     

       10
       10
        
           "webNavigation",

     

       11
       11
        
           "https://*.discord.com/assets/*.js",

     

       12
       12
       +
           "https://moonlight-mod.github.io/*",

     

       13
       13
       +
           "https://api.github.com/*",

     

       12
       14
        
           "https://*.discord.com/*"

     

       13
       15
        
         ],

     

       14
       16
        
         "background": {

+11 -1

packages/browser/src/index.ts

···

       3
       3
        
       import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     

       4
       4
        
       import { getExtensions } from "@moonlight-mod/core/extension";

     

       5
       5
        
       import { loadExtensions } from "@moonlight-mod/core/extension/loader";

     

       6
       6
       -
       import { MoonlightBrowserFS, MoonlightNode } from "@moonlight-mod/types";

     

       6
       6
       +
       import {

     

       7
       7
       +
         MoonlightBranch,

     

       8
       8
       +
         MoonlightBrowserFS,

     

       9
       9
       +
         MoonlightNode

     

       10
       10
       +
       } from "@moonlight-mod/types";

     

       7
       11
        
       import { IndexedDB } from "@zenfs/dom";

     

       8
       12
        
       import { configure } from "@zenfs/core";

     

       9
       13
        
       import * as fs from "@zenfs/core/promises";

     
···

       103
       107
        
           processedExtensions,

     

       104
       108
        
           nativesCache: {},

     

       105
       109
        
       

     

       110
       110
       +
           version: MOONLIGHT_VERSION,

     

       111
       111
       +
           branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       112
       112
       +
       

     

       106
       113
        
           getConfig,

     

       107
       114
        
           getConfigOption: <T>(ext: string, name: string) => {

     

       108
       115
        
             const config = getConfig(ext);

     
···

       116
       123
        
             return new Logger(id);

     

       117
       124
        
           },

     

       118
       125
        
       

     

       126
       126
       +
           getMoonlightDir() {

     

       127
       127
       +
             return "/";

     

       128
       128
       +
           },

     

       119
       129
        
           getExtensionDir: (ext: string) => {

     

       120
       130
        
             return `/extensions/${ext}`;

     

       121
       131
        
           },

+2 -2

packages/core-extensions/package.json

···

       2
       2
        
         "name": "@moonlight-mod/core-extensions",

     

       3
       3
        
         "private": true,

     

       4
       4
        
         "dependencies": {

     

       5
       5
       -
           "@moonlight-mod/types": "workspace:*",

     

       6
       6
       -
           "@moonlight-mod/core": "workspace:*"

     

       5
       5
       +
           "@moonlight-mod/core": "workspace:*",

     

       6
       6
       +
           "@moonlight-mod/types": "workspace:*"

     

       7
       7
        
         }

     

       8
       8
        
       }

+3

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

···

       1
       1
       +
       export const githubRepo = "moonlight-mod/moonlight";

     

       2
       2
       +
       export const nightlyRefUrl = "https://moonlight-mod.github.io/moonlight/ref";

     

       3
       3
       +
       export const userAgent = `moonlight/${moonlightNode.version} (https://github.com/moonlight-mod/moonlight)`;

+17 -3

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

···

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

     

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

     

       2
       2
        
       

     

       3
       3
       -
       export const webpackModules: ExtensionWebExports["webpackModules"] = {

     

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

     

       4
       4
        
         stores: {

     

       5
       5
        
           dependencies: [

     

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

     
···

       29
       29
        
             { ext: "moonbase", id: "ui" }

     

       30
       30
        
           ],

     

       31
       31
        
           entrypoint: true

     

       32
       32
       +
         },

     

       33
       33
       +
       

     

       34
       34
       +
         updates: {

     

       35
       35
       +
           dependencies: [

     

       36
       36
       +
             { id: "react" },

     

       37
       37
       +
             { ext: "moonbase", id: "stores" },

     

       38
       38
       +
             { ext: "notices", id: "notices" },

     

       39
       39
       +
             {

     

       40
       40
       +
               ext: "spacepack",

     

       41
       41
       +
               id: "spacepack"

     

       42
       42
       +
             }

     

       43
       43
       +
           ],

     

       44
       44
       +
           entrypoint: true

     

       32
       45
        
         }

     

       33
       46
        
       };

     

       34
       47
        
       

     

       35
       48
        
       export const styles = [

     

       36
       49
        
         ".moonbase-settings > :first-child { margin-top: 0px; }",

     

       37
       37
       -
         "textarea.moonbase-resizeable  { resize: vertical }"

     

       50
       50
       +
         "textarea.moonbase-resizeable  { resize: vertical }",

     

       51
       51
       +
         ".moonbase-updates-notice { background-color: #222034; color: #FFFBA6; }"

     

       38
       52
        
       ];

+1 -1

packages/core-extensions/src/moonbase/manifest.json

···

       6
       6
        
           "tagline": "The official settings UI for moonlight",

     

       7
       7
        
           "authors": ["Cynosphere", "NotNite"]

     

       8
       8
        
         },

     

       9
       9
       -
         "dependencies": ["spacepack", "settings", "common"],

     

       9
       9
       +
         "dependencies": ["spacepack", "settings", "common", "notices"],

     

       10
       10
        
         "settings": {

     

       11
       11
        
           "sections": {

     

       12
       12
        
             "displayName": "Split into sections",

+43 -2

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

···

       3
       3
        
       import path from "path";

     

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

     

       5
       5
        
       import { repoUrlFile } from "@moonlight-mod/types/constants";

     

       6
       6
       +
       import { githubRepo, userAgent, nightlyRefUrl } from "./consts";

     

       7
       7
       +
       import { MoonlightBranch } from "types/src";

     

       6
       8
        
       

     

       7
       9
        
       const logger = moonlightNode.getLogger("moonbase");

     

       8
       10
        
       

     

       11
       11
       +
       async function checkForMoonlightUpdate() {

     

       12
       12
       +
         try {

     

       13
       13
       +
           if (moonlightNode.branch === MoonlightBranch.STABLE) {

     

       14
       14
       +
             const req = await fetch(

     

       15
       15
       +
               `https://api.github.com/repos/${githubRepo}/releases/latest`,

     

       16
       16
       +
               {

     

       17
       17
       +
                 headers: {

     

       18
       18
       +
                   "User-Agent": userAgent

     

       19
       19
       +
                 }

     

       20
       20
       +
               }

     

       21
       21
       +
             );

     

       22
       22
       +
             const json: { name: string } = await req.json();

     

       23
       23
       +
             return json.name !== moonlightNode.version ? json.name : null;

     

       24
       24
       +
           } else if (moonlightNode.branch === MoonlightBranch.NIGHTLY) {

     

       25
       25
       +
             const req = await fetch(nightlyRefUrl, {

     

       26
       26
       +
               headers: {

     

       27
       27
       +
                 "User-Agent": userAgent

     

       28
       28
       +
               }

     

       29
       29
       +
             });

     

       30
       30
       +
             const ref = (await req.text()).split("\n")[0];

     

       31
       31
       +
             return ref !== moonlightNode.version ? ref : null;

     

       32
       32
       +
           }

     

       33
       33
       +
       

     

       34
       34
       +
           return null;

     

       35
       35
       +
         } catch (e) {

     

       36
       36
       +
           logger.error("Error checking for moonlight update", e);

     

       37
       37
       +
           return null;

     

       38
       38
       +
         }

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       9
       41
        
       async function fetchRepositories(repos: string[]) {

     

       10
       42
        
         const ret: Record<string, RepositoryManifest[]> = {};

     

       11
       43
        
       

     

       12
       44
        
         for (const repo of repos) {

     

       13
       45
        
           try {

     

       14
       14
       -
             const req = await fetch(repo);

     

       46
       46
       +
             const req = await fetch(repo, {

     

       47
       47
       +
               headers: {

     

       48
       48
       +
                 "User-Agent": userAgent

     

       49
       49
       +
               }

     

       50
       50
       +
             });

     

       15
       51
        
             const json = await req.json();

     

       16
       52
        
             ret[repo] = json;

     

       17
       53
        
           } catch (e) {

     
···

       27
       63
        
         url: string,

     

       28
       64
        
         repo: string

     

       29
       65
        
       ) {

     

       30
       30
       -
         const req = await fetch(url);

     

       66
       66
       +
         const req = await fetch(url, {

     

       67
       67
       +
           headers: {

     

       68
       68
       +
             "User-Agent": userAgent

     

       69
       69
       +
           }

     

       70
       70
       +
         });

     

       31
       71
        
       

     

       32
       72
        
         const dir = moonlightNode.getExtensionDir(manifest.id);

     

       33
       73
        
         // remake it in case of updates

     
···

       63
       103
        
       }

     

       64
       104
        
       

     

       65
       105
        
       const exports: MoonbaseNatives = {

     

       106
       106
       +
         checkForMoonlightUpdate,

     

       66
       107
        
         fetchRepositories,

     

       67
       108
        
         installExtension,

     

       68
       109
        
         deleteExtension,

+1

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

···

       1
       1
        
       import { DetectedExtension, ExtensionManifest } from "types/src";

     

       2
       2
        
       

     

       3
       3
        
       export type MoonbaseNatives = {

     

       4
       4
       +
         checkForMoonlightUpdate(): Promise<string | null>;

     

       4
       5
        
         fetchRepositories(

     

       5
       6
        
           repos: string[]

     

       6
       7
        
         ): Promise<Record<string, RepositoryManifest[]>>;

+95 -31

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

···

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

     

       1
       1
       +
       import {

     

       2
       2
       +
         Config,

     

       3
       3
       +
         ExtensionLoadSource,

     

       4
       4
       +
         MoonlightBranch

     

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

     

       2
       6
        
       import {

     

       3
       7
        
         ExtensionState,

     

       4
       8
        
         MoonbaseExtension,

     
···

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

     

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

     

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

     

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

     

       15
       15
       +
       import { mainRepo, repoUrlFile } from "@moonlight-mod/types/constants";

     

       16
       16
       +
       import { githubRepo, userAgent, nightlyRefUrl } from "../consts";

     

       12
       17
        
       

     

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

     

       14
       19
        
       

     
···

       16
       21
        
       if (window._moonlightBrowserFS != null) {

     

       17
       22
        
         const browserFS = window._moonlightBrowserFS!;

     

       18
       23
        
         natives = {

     

       24
       24
       +
           checkForMoonlightUpdate: async () => {

     

       25
       25
       +
             try {

     

       26
       26
       +
               if (moonlight.branch === MoonlightBranch.STABLE) {

     

       27
       27
       +
                 const req = await fetch(

     

       28
       28
       +
                   `https://api.github.com/repos/${githubRepo}/releases/latest`,

     

       29
       29
       +
                   {

     

       30
       30
       +
                     headers: {

     

       31
       31
       +
                       "User-Agent": userAgent

     

       32
       32
       +
                     }

     

       33
       33
       +
                   }

     

       34
       34
       +
                 );

     

       35
       35
       +
                 const json: { name: string } = await req.json();

     

       36
       36
       +
                 return json.name !== moonlight.version ? json.name : null;

     

       37
       37
       +
               } else if (moonlight.branch === MoonlightBranch.NIGHTLY) {

     

       38
       38
       +
                 const req = await fetch(nightlyRefUrl, {

     

       39
       39
       +
                   headers: {

     

       40
       40
       +
                     "User-Agent": userAgent

     

       41
       41
       +
                   }

     

       42
       42
       +
                 });

     

       43
       43
       +
                 const ref = (await req.text()).split("\n")[0];

     

       44
       44
       +
                 return ref !== moonlight.version ? ref : null;

     

       45
       45
       +
               }

     

       46
       46
       +
       

     

       47
       47
       +
               return null;

     

       48
       48
       +
             } catch (e) {

     

       49
       49
       +
               logger.error("Error checking for moonlight update", e);

     

       50
       50
       +
               return null;

     

       51
       51
       +
             }

     

       52
       52
       +
           },

     

       53
       53
       +
       

     

       19
       54
        
           fetchRepositories: async (repos) => {

     

       20
       55
        
             const ret: Record<string, RepositoryManifest[]> = {};

     

       21
       56
        
       

     
···

       77
       112
        
         submitting: boolean;

     

       78
       113
        
         installing: boolean;

     

       79
       114
        
       

     

       115
       115
       +
         newVersion: string | null;

     

       116
       116
       +
         shouldShowNotice: boolean;

     

       117
       117
       +
       

     

       80
       118
        
         extensions: { [id: number]: MoonbaseExtension };

     

       81
       119
        
         updates: { [id: number]: { version: string; download: string } };

     

       82
       120
        
       

     
···

       90
       128
        
           this.modified = false;

     

       91
       129
        
           this.submitting = false;

     

       92
       130
        
           this.installing = false;

     

       131
       131
       +
       

     

       132
       132
       +
           this.newVersion = null;

     

       133
       133
       +
           this.shouldShowNotice = false;

     

       93
       134
        
       

     

       94
       135
        
           this.extensions = {};

     

       95
       136
        
           this.updates = {};

     
···

       104
       145
        
             };

     

       105
       146
        
           }

     

       106
       147
        
       

     

       107
       107
       -
           natives!.fetchRepositories(this.config.repositories).then((ret) => {

     

       108
       108
       -
             for (const [repo, exts] of Object.entries(ret)) {

     

       109
       109
       -
               try {

     

       110
       110
       -
                 for (const ext of exts) {

     

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

     

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

     

       148
       148
       +
           natives!

     

       149
       149
       +
             .fetchRepositories(this.config.repositories)

     

       150
       150
       +
             .then((ret) => {

     

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

     

       152
       152
       +
                 try {

     

       153
       153
       +
                   for (const ext of exts) {

     

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

     

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

     

       113
       156
        
       

     

       114
       114
       -
                   const uniqueId = this.extensionIndex++;

     

       115
       115
       -
                   const extensionData = {

     

       116
       116
       -
                     id: ext.id,

     

       117
       117
       -
                     uniqueId,

     

       118
       118
       -
                     manifest: ext,

     

       119
       119
       -
                     source: { type: ExtensionLoadSource.Normal, url: repo },

     

       120
       120
       -
                     state: ExtensionState.NotDownloaded

     

       121
       121
       -
                   };

     

       157
       157
       +
                     const uniqueId = this.extensionIndex++;

     

       158
       158
       +
                     const extensionData = {

     

       159
       159
       +
                       id: ext.id,

     

       160
       160
       +
                       uniqueId,

     

       161
       161
       +
                       manifest: ext,

     

       162
       162
       +
                       source: { type: ExtensionLoadSource.Normal, url: repo },

     

       163
       163
       +
                       state: ExtensionState.NotDownloaded

     

       164
       164
       +
                     };

     

       165
       165
       +
       

     

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

     

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

     

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

     

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

     

       170
       170
       +
                           this.extensions[parseInt(id)].manifest = {

     

       171
       171
       +
                             ...e.manifest,

     

       172
       172
       +
                             download: ext.download

     

       173
       173
       +
                           };

     

       174
       174
       +
                           break;

     

       175
       175
       +
                         }

     

       176
       176
       +
                       }

     

       177
       177
       +
       

     

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

     

       179
       179
       +
                         this.updates[uniqueId] = {

     

       180
       180
       +
                           version: ext.version!,

     

       181
       181
       +
                           download: ext.download

     

       182
       182
       +
                         };

     

       183
       183
       +
                       }

     

       122
       184
        
       

     

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

     

       124
       124
       -
                     if (this.hasUpdate(extensionData)) {

     

       125
       125
       -
                       this.updates[uniqueId] = {

     

       126
       126
       -
                         version: ext.version!,

     

       127
       127
       -
                         download: ext.download

     

       128
       128
       -
                       };

     

       185
       185
       +
                       continue;

     

       129
       186
        
                     }

     

       130
       187
        
       

     

       131
       131
       -
                     continue;

     

       188
       188
       +
                     this.extensions[uniqueId] = extensionData;

     

       132
       189
        
                   }

     

       133
       133
       -
       

     

       134
       134
       -
                   this.extensions[uniqueId] = extensionData;

     

       190
       190
       +
                 } catch (e) {

     

       191
       191
       +
                   logger.error(`Error processing repository ${repo}`, e);

     

       135
       192
        
                 }

     

       136
       136
       -
               } catch (e) {

     

       137
       137
       -
                 logger.error(`Error processing repository ${repo}`, e);

     

       138
       193
        
               }

     

       139
       139
       -
             }

     

       140
       194
        
       

     

       141
       141
       -
             this.emitChange();

     

       142
       142
       -
           });

     

       195
       195
       +
               this.emitChange();

     

       196
       196
       +
             })

     

       197
       197
       +
             .then(natives!.checkForMoonlightUpdate)

     

       198
       198
       +
             .then((version) => {

     

       199
       199
       +
               this.newVersion = version;

     

       200
       200
       +
               this.emitChange();

     

       201
       201
       +
             })

     

       202
       202
       +
             .then(() => {

     

       203
       203
       +
               this.shouldShowNotice =

     

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

     

       205
       205
       +
               this.emitChange();

     

       206
       206
       +
             });

     

       143
       207
        
         }

     

       144
       208
        
       

     

       145
       209
        
         private alreadyExists(ext: MoonbaseExtension) {

     
···

       299
       363
        
         private getRank(ext: MoonbaseExtension) {

     

       300
       364
        
           if (ext.source.type === ExtensionLoadSource.Developer) return 3;

     

       301
       365
        
           if (ext.source.type === ExtensionLoadSource.Core) return 2;

     

       302
       302
       -
           if (ext.source.url === constants.mainRepo) return 1;

     

       366
       366
       +
           if (ext.source.url === mainRepo) return 1;

     

       303
       367
        
           return 0;

     

       304
       368
        
         }

     

       305
       369

+81

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

···

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

     

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

     

       3
       3
       +
       import Notices from "@moonlight-mod/wp/notices_notices";

     

       4
       4
       +
       import { MoonlightBranch } from "types/src";

     

       5
       5
       +
       

     

       6
       6
       +
       // FIXME: not indexed as importable

     

       7
       7
       +
       const Constants = spacepack.require("discord/Constants");

     

       8
       8
       +
       const UserSettingsSections = spacepack.findObjectFromKey(

     

       9
       9
       +
         Constants,

     

       10
       10
       +
         "APPEARANCE_THEME_PICKER"

     

       11
       11
       +
       );

     

       12
       12
       +
       

     

       13
       13
       +
       function plural(str: string, num: number) {

     

       14
       14
       +
         return `${str}${num > 1 ? "s" : ""}`;

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       function listener() {

     

       18
       18
       +
         if (MoonbaseSettingsStore.shouldShowNotice) {

     

       19
       19
       +
           // @ts-expect-error epic type fail

     

       20
       20
       +
           MoonbaseSettingsStore.removeChangeListener(listener);

     

       21
       21
       +
       

     

       22
       22
       +
           const version = MoonbaseSettingsStore.newVersion;

     

       23
       23
       +
           const extensionUpdateCount = Object.keys(

     

       24
       24
       +
             MoonbaseSettingsStore.updates

     

       25
       25
       +
           ).length;

     

       26
       26
       +
           const hasExtensionUpdates = extensionUpdateCount > 0;

     

       27
       27
       +
       

     

       28
       28
       +
           let message;

     

       29
       29
       +
       

     

       30
       30
       +
           if (version != null) {

     

       31
       31
       +
             message =

     

       32
       32
       +
               moonlightNode.branch === MoonlightBranch.NIGHTLY

     

       33
       33
       +
                 ? `A new version of moonlight is available`

     

       34
       34
       +
                 : `moonlight ${version} is available`;

     

       35
       35
       +
           }

     

       36
       36
       +
       

     

       37
       37
       +
           if (hasExtensionUpdates) {

     

       38
       38
       +
             let concat = false;

     

       39
       39
       +
             if (message == null) {

     

       40
       40
       +
               message = "";

     

       41
       41
       +
             } else {

     

       42
       42
       +
               concat = true;

     

       43
       43
       +
               message += ", and ";

     

       44
       44
       +
             }

     

       45
       45
       +
             message += `${extensionUpdateCount} ${concat ? "" : "moonlight "}${plural(

     

       46
       46
       +
               "extension",

     

       47
       47
       +
               extensionUpdateCount

     

       48
       48
       +
             )} can be updated`;

     

       49
       49
       +
           }

     

       50
       50
       +
       

     

       51
       51
       +
           if (message != null) message += ".";

     

       52
       52
       +
       

     

       53
       53
       +
           Notices.addNotice({

     

       54
       54
       +
             element: message,

     

       55
       55
       +
             color: "moonbase-updates-notice",

     

       56
       56
       +
             buttons: hasExtensionUpdates

     

       57
       57
       +
               ? [

     

       58
       58
       +
                   {

     

       59
       59
       +
                     name: "Open Moonbase",

     

       60
       60
       +
                     onClick: () => {

     

       61
       61
       +
                       const { open } = spacepack.findByExports(

     

       62
       62
       +
                         "setSection",

     

       63
       63
       +
                         "clearSubsection"

     

       64
       64
       +
                       )[0].exports.Z;

     

       65
       65
       +
       

     

       66
       66
       +
                       // settings is lazy loaded thus lazily patched

     

       67
       67
       +
                       // FIXME: figure out a way to detect if settings has been opened

     

       68
       68
       +
                       //        alreadyjust so the transition isnt as jarring

     

       69
       69
       +
                       open(UserSettingsSections.ACCOUNT);

     

       70
       70
       +
                       setTimeout(() => open("moonbase", 0), 0);

     

       71
       71
       +
                       return true;

     

       72
       72
       +
                     }

     

       73
       73
       +
                   }

     

       74
       74
       +
                 ]

     

       75
       75
       +
               : []

     

       76
       76
       +
           });

     

       77
       77
       +
         }

     

       78
       78
       +
       }

     

       79
       79
       +
       

     

       80
       80
       +
       // @ts-expect-error epic type fail

     

       81
       81
       +
       MoonbaseSettingsStore.addChangeListener(listener);

+6 -2

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

···

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

     

       65
       65
        
         !noAccel

     

       66
       66
        
       ) {

     

       67
       67
       -
         enabledFeatures.push("VaapiVideoEncoder", "VaapiVideoDecoder");

     

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

     

       69
       69
       -
           enabledFeatures.push("VaapiVideoDecodeLinuxGL");

     

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

     

       69
       69
       +
           enabledFeatures.push(

     

       70
       70
       +
             "VaapiVideoEncoder",

     

       71
       71
       +
             "VaapiVideoDecoder",

     

       72
       72
       +
             "VaapiVideoDecodeLinuxGL"

     

       73
       73
       +
           );

     

       70
       74
        
       }

     

       71
       75
        
       

     

       72
       76
        
       app.commandLine.appendSwitch(

+5 -10

packages/core-extensions/src/nativeFixes/manifest.json

···

       3
       3
        
         "meta": {

     

       4
       4
        
           "name": "Native Fixes",

     

       5
       5
        
           "tagline": "Various configurable fixes for Discord and Electron",

     

       6
       6
       -
           "authors": [

     

       7
       7
       -
             "Cynosphere",

     

       8
       8
       -
             "adryd"

     

       9
       9
       -
           ],

     

       10
       10
       -
           "tags": [

     

       11
       11
       -
             "fixes"

     

       12
       12
       -
           ]

     

       6
       6
       +
           "authors": ["Cynosphere", "adryd"],

     

       7
       7
       +
           "tags": ["fixes"]

     

       13
       8
        
         },

     

       14
       9
        
         "settings": {

     

       15
       10
        
           "devtoolsThemeFix": {

     
···

       32
       27
        
           },

     

       33
       28
        
           "linuxSpeechDispatcher": {

     

       34
       29
        
             "displayName": "Enable speech-dispatcher for TTS on Linux",

     

       35
       35
       -
             "description": "Has no effect on other operating systems",

     

       30
       30
       +
             "description": "Fixes text-to-speech. Has no effect on other operating systems",

     

       36
       31
        
             "type": "boolean",

     

       37
       32
        
             "default": true

     

       38
       33
        
           },

     

       39
       34
        
           "vaapi": {

     

       40
       40
       -
             "displayName": "Enable VAAPI features",

     

       41
       41
       -
             "description": "Provides additional hardware acceleration",

     

       35
       35
       +
             "displayName": "Enable VAAPI features on Linux",

     

       36
       36
       +
             "description": "Provides hardware accelerated video encode and decode. Has no effect on other operating systems",

     

       42
       37
        
             "type": "boolean",

     

       43
       38
        
             "default": true

     

       44
       39
        
           }

+2 -1

packages/core-extensions/src/noHideToken/manifest.json

···

       3
       3
        
         "apiLevel": 2,

     

       4
       4
        
         "meta": {

     

       5
       5
        
           "name": "No Hide Token",

     

       6
       6
       -
           "tagline": "Disables removal of token from localStorage when opening dev tools",

     

       6
       6
       +
           "tagline": "Prevents you from being logged-out on hard-crash",

     

       7
       7
       +
           "description": "Prevents you from being logged-out on hard-crash by disabling removal of token from localStorage when opening dev tools",

     

       7
       8
        
           "authors": ["adryd"],

     

       8
       9
        
           "tags": ["dangerZone", "development"]

     

       9
       10
        
         }

+46

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

···

       1
       1
       +
       import type { ExtensionWebpackModule, Patch } from "@moonlight-mod/types";

     

       2
       2
       +
       

     

       3
       3
       +
       export const patches: Patch[] = [

     

       4
       4
       +
         {

     

       5
       5
       +
           find: ".GUILD_RAID_NOTIFICATION:",

     

       6
       6
       +
           replace: {

     

       7
       7
       +
             match:

     

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

     

       9
       9
       +
             replacement: (orig, createElement) =>

     

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

     

       11
       11
       +
           }

     

       12
       12
       +
         },

     

       13
       13
       +
         {

     

       14
       14
       +
           find: '"NoticeStore"',

     

       15
       15
       +
           replace: [

     

       16
       16
       +
             {

     

       17
       17
       +
               match: /\[.{1,2}\..{1,3}\.CONNECT_SPOTIFY\]:{/,

     

       18
       18
       +
               replacement: (orig: string) =>

     

       19
       19
       +
                 `__moonlight_notice:{predicate:()=>require("notices_notices").default.shouldShowNotice()},${orig}`

     

       20
       20
       +
             },

     

       21
       21
       +
             {

     

       22
       22
       +
               match: /=\[(.{1,2}\..{1,3}\.QUARANTINED,)/g,

     

       23
       23
       +
               replacement: (_, orig) => `=["__moonlight_notice",${orig}`

     

       24
       24
       +
             }

     

       25
       25
       +
           ]

     

       26
       26
       +
         }

     

       27
       27
       +
       ];

     

       28
       28
       +
       

     

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

     

       30
       30
       +
         notices: {

     

       31
       31
       +
           dependencies: [

     

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

     

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

     

       34
       34
       +
           ]

     

       35
       35
       +
         },

     

       36
       36
       +
       

     

       37
       37
       +
         component: {

     

       38
       38
       +
           dependencies: [

     

       39
       39
       +
             { id: "react" },

     

       40
       40
       +
             { id: "discord/Dispatcher" },

     

       41
       41
       +
             { id: "discord/components/common/index" },

     

       42
       42
       +
             { id: "discord/packages/flux" },

     

       43
       43
       +
             { ext: "notices", id: "notices" }

     

       44
       44
       +
           ]

     

       45
       45
       +
         }

     

       46
       46
       +
       };

+10

packages/core-extensions/src/notices/manifest.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "id": "notices",

     

       3
       3
       +
         "apiLevel": 2,

     

       4
       4
       +
         "meta": {

     

       5
       5
       +
           "name": "Notices",

     

       6
       6
       +
           "tagline": "An API for adding notices at the top of the page",

     

       7
       7
       +
           "authors": ["Cynosphere", "NotNite"],

     

       8
       8
       +
           "tags": ["library"]

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+56

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

···

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

     

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

     

       3
       3
       +
       import * as Components from "@moonlight-mod/wp/discord/components/common/index";

     

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

     

       5
       5
       +
       import NoticesStore from "@moonlight-mod/wp/notices_notices";

     

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

     

       7
       7
       +
       

     

       8
       8
       +
       // FIXME: types

     

       9
       9
       +
       const { Notice, NoticeCloseButton, PrimaryCTANoticeButton } = Components;

     

       10
       10
       +
       

     

       11
       11
       +
       function popAndDismiss(notice: Notice) {

     

       12
       12
       +
         NoticesStore.popNotice();

     

       13
       13
       +
         if (notice?.onDismiss) {

     

       14
       14
       +
           notice.onDismiss();

     

       15
       15
       +
         }

     

       16
       16
       +
         if (!NoticesStore.shouldShowNotice()) {

     

       17
       17
       +
           Dispatcher.dispatch({

     

       18
       18
       +
             type: "NOTICE_DISMISS"

     

       19
       19
       +
           });

     

       20
       20
       +
         }

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       export default function UpdateNotice() {

     

       24
       24
       +
         const { notice } = useStateFromStoresObject([NoticesStore], () => ({

     

       25
       25
       +
           notice: NoticesStore.getCurrentNotice()

     

       26
       26
       +
         }));

     

       27
       27
       +
       

     

       28
       28
       +
         if (notice == null) return <></>;

     

       29
       29
       +
       

     

       30
       30
       +
         return (

     

       31
       31
       +
           <Notice color={notice.color}>

     

       32
       32
       +
             {notice.element}

     

       33
       33
       +
       

     

       34
       34
       +
             {(notice.showClose ?? true) && (

     

       35
       35
       +
               <NoticeCloseButton

     

       36
       36
       +
                 onClick={() => popAndDismiss(notice)}

     

       37
       37
       +
                 noticeType="__moonlight_notice"

     

       38
       38
       +
               />

     

       39
       39
       +
             )}

     

       40
       40
       +
       

     

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

     

       42
       42
       +
               <PrimaryCTANoticeButton

     

       43
       43
       +
                 key={button.name}

     

       44
       44
       +
                 onClick={() => {

     

       45
       45
       +
                   if (button.onClick()) {

     

       46
       46
       +
                     popAndDismiss(notice);

     

       47
       47
       +
                   }

     

       48
       48
       +
                 }}

     

       49
       49
       +
                 noticeType="__moonlight_notice"

     

       50
       50
       +
               >

     

       51
       51
       +
                 {button.name}

     

       52
       52
       +
               </PrimaryCTANoticeButton>

     

       53
       53
       +
             ))}

     

       54
       54
       +
           </Notice>

     

       55
       55
       +
         );

     

       56
       56
       +
       }

+58

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

···

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

     

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

     

       3
       3
       +
       import type {

     

       4
       4
       +
         Notice,

     

       5
       5
       +
         Notices

     

       6
       6
       +
       } from "@moonlight-mod/types/coreExtensions/notices";

     

       7
       7
       +
       

     

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

     

       9
       9
       +
       let open = false;

     

       10
       10
       +
       

     

       11
       11
       +
       class NoticesStore extends Store<any> {

     

       12
       12
       +
         private notices: Notice[] = [];

     

       13
       13
       +
       

     

       14
       14
       +
         constructor() {

     

       15
       15
       +
           super(Dispatcher);

     

       16
       16
       +
         }

     

       17
       17
       +
       

     

       18
       18
       +
         addNotice(notice: Notice) {

     

       19
       19
       +
           this.notices.push(notice);

     

       20
       20
       +
           if (open && this.notices.length !== 0) {

     

       21
       21
       +
             Dispatcher.dispatch({

     

       22
       22
       +
               type: "NOTICE_SHOW",

     

       23
       23
       +
               notice: { type: "__moonlight_notice" }

     

       24
       24
       +
             });

     

       25
       25
       +
           }

     

       26
       26
       +
           this.emitChange();

     

       27
       27
       +
         }

     

       28
       28
       +
       

     

       29
       29
       +
         popNotice() {

     

       30
       30
       +
           this.notices.shift();

     

       31
       31
       +
           this.emitChange();

     

       32
       32
       +
         }

     

       33
       33
       +
       

     

       34
       34
       +
         getCurrentNotice() {

     

       35
       35
       +
           return this.notices.length > 0 ? this.notices[0] : null;

     

       36
       36
       +
         }

     

       37
       37
       +
       

     

       38
       38
       +
         shouldShowNotice() {

     

       39
       39
       +
           return this.notices.length > 0;

     

       40
       40
       +
         }

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       const store: Notices = new NoticesStore();

     

       44
       44
       +
       

     

       45
       45
       +
       function showNotice() {

     

       46
       46
       +
         open = true;

     

       47
       47
       +
         if (store.shouldShowNotice()) {

     

       48
       48
       +
           Dispatcher.dispatch({

     

       49
       49
       +
             type: "NOTICE_SHOW",

     

       50
       50
       +
             notice: { type: "__moonlight_notice" }

     

       51
       51
       +
           });

     

       52
       52
       +
         }

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       Dispatcher.subscribe("CONNECTION_OPEN", showNotice);

     

       56
       56
       +
       Dispatcher.subscribe("CONNECTION_OPEN_SUPPLEMENTAL", showNotice);

     

       57
       57
       +
       

     

       58
       58
       +
       export default store;

+2

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

···

       1
       1
       +
       import "./host/permissions";

     

       2
       2
       +
       import "./host/venmic";

+96

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

···

       1
       1
       +
       import type { BrowserWindow } from "electron";

     

       2
       2
       +
       

     

       3
       3
       +
       type PermissionRequestHandler = (

     

       4
       4
       +
         webContents: Electron.WebContents,

     

       5
       5
       +
         permission: string,

     

       6
       6
       +
         callback: (permissionGranted: boolean) => void,

     

       7
       7
       +
         details: Electron.PermissionRequestHandlerHandlerDetails

     

       8
       8
       +
       ) => void;

     

       9
       9
       +
       

     

       10
       10
       +
       type PermissionCheckHandler = (

     

       11
       11
       +
         webContents: Electron.WebContents | null,

     

       12
       12
       +
         permission: string,

     

       13
       13
       +
         requestingOrigin: string,

     

       14
       14
       +
         details: Electron.PermissionCheckHandlerHandlerDetails

     

       15
       15
       +
       ) => boolean;

     

       16
       16
       +
       

     

       17
       17
       +
       moonlightHost.events.on(

     

       18
       18
       +
         "window-created",

     

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

     

       20
       20
       +
           if (!isMainWindow) return;

     

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

     

       22
       22
       +
       

     

       23
       23
       +
           // setPermissionRequestHandler

     

       24
       24
       +
           windowSession.setPermissionRequestHandler(

     

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

     

       26
       26
       +
               let cbResult = false;

     

       27
       27
       +
               function fakeCallback(result: boolean) {

     

       28
       28
       +
                 cbResult = result;

     

       29
       29
       +
               }

     

       30
       30
       +
       

     

       31
       31
       +
               if (caughtPermissionRequestHandler) {

     

       32
       32
       +
                 caughtPermissionRequestHandler(

     

       33
       33
       +
                   webcontents,

     

       34
       34
       +
                   permission,

     

       35
       35
       +
                   fakeCallback,

     

       36
       36
       +
                   details

     

       37
       37
       +
                 );

     

       38
       38
       +
               }

     

       39
       39
       +
       

     

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

     

       41
       41
       +
                 cbResult = true;

     

       42
       42
       +
               }

     

       43
       43
       +
       

     

       44
       44
       +
               callback(cbResult);

     

       45
       45
       +
             }

     

       46
       46
       +
           );

     

       47
       47
       +
       

     

       48
       48
       +
           let caughtPermissionRequestHandler: PermissionRequestHandler | undefined;

     

       49
       49
       +
       

     

       50
       50
       +
           windowSession.setPermissionRequestHandler =

     

       51
       51
       +
             function catchSetPermissionRequestHandler(

     

       52
       52
       +
               handler: (

     

       53
       53
       +
                 webcontents: Electron.WebContents,

     

       54
       54
       +
                 permission: string,

     

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

     

       56
       56
       +
               ) => void

     

       57
       57
       +
             ) {

     

       58
       58
       +
               caughtPermissionRequestHandler = handler;

     

       59
       59
       +
             };

     

       60
       60
       +
       

     

       61
       61
       +
           // setPermissionCheckHandler

     

       62
       62
       +
           windowSession.setPermissionCheckHandler(

     

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

     

       64
       64
       +
               return false;

     

       65
       65
       +
             }

     

       66
       66
       +
           );

     

       67
       67
       +
       

     

       68
       68
       +
           let caughtPermissionCheckHandler: PermissionCheckHandler | undefined;

     

       69
       69
       +
       

     

       70
       70
       +
           windowSession.setPermissionCheckHandler(

     

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

     

       72
       72
       +
               let result = false;

     

       73
       73
       +
       

     

       74
       74
       +
               if (caughtPermissionCheckHandler) {

     

       75
       75
       +
                 result = caughtPermissionCheckHandler(

     

       76
       76
       +
                   webcontents,

     

       77
       77
       +
                   permission,

     

       78
       78
       +
                   requestingOrigin,

     

       79
       79
       +
                   details

     

       80
       80
       +
                 );

     

       81
       81
       +
               }

     

       82
       82
       +
       

     

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

     

       84
       84
       +
                 result = true;

     

       85
       85
       +
               }

     

       86
       86
       +
       

     

       87
       87
       +
               return result;

     

       88
       88
       +
             }

     

       89
       89
       +
           );

     

       90
       90
       +
       

     

       91
       91
       +
           windowSession.setPermissionCheckHandler =

     

       92
       92
       +
             function catchSetPermissionCheckHandler(handler: PermissionCheckHandler) {

     

       93
       93
       +
               caughtPermissionCheckHandler = handler;

     

       94
       94
       +
             };

     

       95
       95
       +
         }

     

       96
       96
       +
       );

+35

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

···

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

     

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

     

       3
       3
       +
       

     

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

     

       5
       5
       +
         | LiteralType

     

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

     

       7
       7
       +
       

     

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

     

       9
       9
       +
         Omit<Type, Key>;

     

       10
       10
       +
       

     

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

     

       12
       12
       +
         LiteralUnion<T, string>,

     

       13
       13
       +
         string

     

       14
       14
       +
       >;

     

       15
       15
       +
       

     

       16
       16
       +
       export interface LinkData {

     

       17
       17
       +
         include: Node[];

     

       18
       18
       +
         exclude: Node[];

     

       19
       19
       +
       

     

       20
       20
       +
         ignore_devices?: boolean;

     

       21
       21
       +
       

     

       22
       22
       +
         only_speakers?: boolean;

     

       23
       23
       +
         only_default_speakers?: boolean;

     

       24
       24
       +
       

     

       25
       25
       +
         workaround?: Node[];

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       export interface PatchBay {

     

       29
       29
       +
         unlink(): void;

     

       30
       30
       +
       

     

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

     

       32
       32
       +
         link(

     

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

     

       34
       34
       +
         ): boolean;

     

       35
       35
       +
       }

+77

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

···

       1
       1
       +
       import type { BrowserWindow } from "electron";

     

       2
       2
       +
       import { app, desktopCapturer } from "electron";

     

       3
       3
       +
       import path from "node:path";

     

       4
       4
       +
       import { type PatchBay } from "./types";

     

       5
       5
       +
       

     

       6
       6
       +
       const logger = moonlightHost.getLogger("rocketship");

     

       7
       7
       +
       

     

       8
       8
       +
       function getPatchbay() {

     

       9
       9
       +
         try {

     

       10
       10
       +
           const venmic = require(

     

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

     

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

     

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

     

       14
       14
       +
           return patchbay;

     

       15
       15
       +
         } catch (error) {

     

       16
       16
       +
           logger.error("Failed to load venmic.node:", error);

     

       17
       17
       +
           return null;

     

       18
       18
       +
         }

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       const patchbay = getPatchbay();

     

       22
       22
       +
       

     

       23
       23
       +
       // TODO: figure out how to map source to window with venmic

     

       24
       24
       +
       function linkVenmic() {

     

       25
       25
       +
         if (patchbay == null) return false;

     

       26
       26
       +
       

     

       27
       27
       +
         try {

     

       28
       28
       +
           const pid =

     

       29
       29
       +
             app

     

       30
       30
       +
               .getAppMetrics()

     

       31
       31
       +
               .find((proc) => proc.name === "Audio Service")

     

       32
       32
       +
               ?.pid?.toString() ?? "";

     

       33
       33
       +
       

     

       34
       34
       +
           logger.info("Audio Service PID:", pid);

     

       35
       35
       +
       

     

       36
       36
       +
           patchbay.unlink();

     

       37
       37
       +
           return patchbay.link({

     

       38
       38
       +
             exclude: [

     

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

     

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

     

       41
       41
       +
             ],

     

       42
       42
       +
             ignore_devices: true,

     

       43
       43
       +
             only_speakers: true,

     

       44
       44
       +
             only_default_speakers: true

     

       45
       45
       +
           });

     

       46
       46
       +
         } catch (error) {

     

       47
       47
       +
           logger.error("Failed to link venmic:", error);

     

       48
       48
       +
           return false;

     

       49
       49
       +
         }

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       moonlightHost.events.on(

     

       53
       53
       +
         "window-created",

     

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

     

       55
       55
       +
           if (!isMainWindow) return;

     

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

     

       57
       57
       +
       

     

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

     

       59
       59
       +
           windowSession.setDisplayMediaRequestHandler(

     

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

     

       61
       61
       +
               const linked = linkVenmic();

     

       62
       62
       +
               desktopCapturer

     

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

     

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

     

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

     

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

     

       67
       67
       +
       

     

       68
       68
       +
                   callback({

     

       69
       69
       +
                     video: sources[0],

     

       70
       70
       +
                     audio: "loopback"

     

       71
       71
       +
                   });

     

       72
       72
       +
                 });

     

       73
       73
       +
             },

     

       74
       74
       +
             { useSystemPicker: true }

     

       75
       75
       +
           );

     

       76
       76
       +
         }

     

       77
       77
       +
       );

+130

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

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       const logger = moonlight.getLogger("rocketship");

     

       4
       4
       +
       const getDisplayMediaOrig = navigator.mediaDevices.getDisplayMedia;

     

       5
       5
       +
       

     

       6
       6
       +
       async function getVenmicStream() {

     

       7
       7
       +
         try {

     

       8
       8
       +
           const devices = await navigator.mediaDevices.enumerateDevices();

     

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

     

       10
       10
       +
       

     

       11
       11
       +
           // This isn't vencord :(

     

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

     

       13
       13
       +
             ?.deviceId;

     

       14
       14
       +
           if (!id) return null;

     

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

     

       16
       16
       +
       

     

       17
       17
       +
           const stream = await navigator.mediaDevices.getUserMedia({

     

       18
       18
       +
             audio: {

     

       19
       19
       +
               deviceId: {

     

       20
       20
       +
                 exact: id

     

       21
       21
       +
               },

     

       22
       22
       +
               autoGainControl: false,

     

       23
       23
       +
               echoCancellation: false,

     

       24
       24
       +
               noiseSuppression: false

     

       25
       25
       +
             }

     

       26
       26
       +
           });

     

       27
       27
       +
       

     

       28
       28
       +
           return stream.getAudioTracks();

     

       29
       29
       +
         } catch (error) {

     

       30
       30
       +
           logger.warn("Failed to get venmic stream:", error);

     

       31
       31
       +
           return null;

     

       32
       32
       +
         }

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

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

     

       36
       36
       +
         options

     

       37
       37
       +
       ) {

     

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

     

       39
       39
       +
       

     

       40
       40
       +
         const venmic = await getVenmicStream();

     

       41
       41
       +
         logger.debug("venmic", venmic);

     

       42
       42
       +
         if (venmic != null) {

     

       43
       43
       +
           // venmic will be proxying all audio, so we need to remove the original

     

       44
       44
       +
           // tracks to not cause overlap

     

       45
       45
       +
           for (const track of orig.getAudioTracks()) {

     

       46
       46
       +
             orig.removeTrack(track);

     

       47
       47
       +
           }

     

       48
       48
       +
       

     

       49
       49
       +
           for (const track of venmic) {

     

       50
       50
       +
             orig.addTrack(track);

     

       51
       51
       +
           }

     

       52
       52
       +
         }

     

       53
       53
       +
       

     

       54
       54
       +
         return orig;

     

       55
       55
       +
       };

     

       56
       56
       +
       

     

       57
       57
       +
       export const patches: Patch[] = [

     

       58
       58
       +
         // "Ensure discord_voice is happy"

     

       59
       59
       +
         {

     

       60
       60
       +
           find: "RustAudioDeviceModule",

     

       61
       61
       +
           replace: [

     

       62
       62
       +
             {

     

       63
       63
       +
               match: /static supported\(\)\{.+?\}/,

     

       64
       64
       +
               replacement: "static supported(){return true}"

     

       65
       65
       +
             },

     

       66
       66
       +
             {

     

       67
       67
       +
               match: "supported(){return!0}",

     

       68
       68
       +
               replacement: "supported(){return true}"

     

       69
       69
       +
             }

     

       70
       70
       +
           ]

     

       71
       71
       +
         },

     

       72
       72
       +
         // Remove Native media engine from list of choices

     

       73
       73
       +
         {

     

       74
       74
       +
           find: '.CAMERA_BACKGROUND_LIVE="cameraBackgroundLive"',

     

       75
       75
       +
           replace: {

     

       76
       76
       +
             match: /.\..{1,2}\.NATIVE,/,

     

       77
       77
       +
             replacement: ""

     

       78
       78
       +
           }

     

       79
       79
       +
         },

     

       80
       80
       +
         // Stub out browser checks to allow us to use WebRTC voice on Embedded

     

       81
       81
       +
         {

     

       82
       82
       +
           find: "Using Unified Plan (",

     

       83
       83
       +
           replace: {

     

       84
       84
       +
             match: /return .\..{1,2}\?\((.)\.info/,

     

       85
       85
       +
             replacement: (_, logger) => `return true?(${logger}.info`

     

       86
       86
       +
           }

     

       87
       87
       +
         },

     

       88
       88
       +
         {

     

       89
       89
       +
           find: '"UnifiedConnection("',

     

       90
       90
       +
           replace: {

     

       91
       91
       +
             match: /this\.videoSupported=.\..{1,2};/,

     

       92
       92
       +
             replacement: "this.videoSupported=true;"

     

       93
       93
       +
           }

     

       94
       94
       +
         },

     

       95
       95
       +
         {

     

       96
       96
       +
           find: "OculusBrowser",

     

       97
       97
       +
           replace: [

     

       98
       98
       +
             {

     

       99
       99
       +
               match: /"Firefox"===(.)\(\)\.name/g,

     

       100
       100
       +
               replacement: (orig, info) => `true||${orig}`

     

       101
       101
       +
             }

     

       102
       102
       +
           ]

     

       103
       103
       +
         },

     

       104
       104
       +
         {

     

       105
       105
       +
           find: ".getMediaEngine().getDesktopSource",

     

       106
       106
       +
           replace: {

     

       107
       107
       +
             match: /.\.isPlatformEmbedded/,

     

       108
       108
       +
             replacement: "false"

     

       109
       109
       +
           }

     

       110
       110
       +
         },

     

       111
       111
       +
         {

     

       112
       112
       +
           // Matching MediaEngineStore

     

       113
       113
       +
           find: '"displayName","MediaEngineStore")',

     

       114
       114
       +
           replace: [

     

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

     

       116
       116
       +
             {

     

       117
       117
       +
               match:

     

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

     

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

     

       120
       120
       +
             },

     

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

     

       122
       122
       +
             {

     

       123
       123
       +
               match:

     

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

     

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

     

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

     

       127
       127
       +
             }

     

       128
       128
       +
           ]

     

       129
       129
       +
         }

     

       130
       130
       +
       ];

+10

packages/core-extensions/src/rocketship/manifest.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "id": "rocketship",

     

       3
       3
       +
         "apiLevel": 2,

     

       4
       4
       +
         "meta": {

     

       5
       5
       +
           "name": "Rocketship",

     

       6
       6
       +
           "tagline": "Adds new features when using rocketship",

     

       7
       7
       +
           "description": "**This extension only works on Linux when using rocketship: https://github.com/moonlight-mod/rocketship**. Adds new features to the Discord Linux client with rocketship, like better screensharing.",

     

       8
       8
       +
           "authors": ["NotNite", "Cynosphere", "adryd"]

     

       9
       9
       +
         }

     

       10
       10
       +
       }

+3 -3

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

···

       5
       5
        
         {

     

       6
       6
        
           find: '"useGenerateUserSettingsSections"',

     

       7
       7
        
           replace: {

     

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

     

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

     

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

     

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

     

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

     

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

     

       11
       11
        
           }

     

       12
       12
        
         },

     

       13
       13
        
         {

+10 -6

packages/injector/src/index.ts

···

       5
       5
        
         app

     

       6
       6
        
       } from "electron";

     

       7
       7
        
       import Module from "node:module";

     

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

     

       8
       8
       +
       import { constants, MoonlightBranch } from "@moonlight-mod/types";

     

       9
       9
        
       import { readConfig } from "@moonlight-mod/core/config";

     

       10
       10
        
       import { getExtensions } from "@moonlight-mod/core/extension";

     

       11
       11
        
       import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     
···

       123
       123
        
         constructor(opts: BrowserWindowConstructorOptions) {

     

       124
       124
        
           oldPreloadPath = opts.webPreferences!.preload;

     

       125
       125
        
       

     

       126
       126
       -
           // Only overwrite preload if its the actual main client window

     

       127
       127
       -
           if (opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1) {

     

       126
       126
       +
           const isMainWindow =

     

       127
       127
       +
             opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1;

     

       128
       128
       +
       

     

       129
       129
       +
           if (isMainWindow)

     

       128
       130
        
             opts.webPreferences!.preload = require.resolve("./node-preload.js");

     

       129
       129
       -
           }

     

       130
       131
        
       

     

       131
       132
        
           // Event for modifying window options

     

       132
       132
       -
           moonlightHost.events.emit("window-options", opts);

     

       133
       133
       +
           moonlightHost.events.emit("window-options", opts, isMainWindow);

     

       133
       134
        
       

     

       134
       135
        
           super(opts);

     

       135
       136
        
       

     

       136
       137
        
           // Event for when a window is created

     

       137
       137
       -
           moonlightHost.events.emit("window-created", this);

     

       138
       138
       +
           moonlightHost.events.emit("window-created", this, isMainWindow);

     

       138
       139
        
       

     

       139
       140
        
           this.webContents.session.webRequest.onHeadersReceived((details, cb) => {

     

       140
       141
        
             if (details.responseHeaders != null) {

     
···

       222
       223
        
               extensions: [],

     

       223
       224
        
               dependencyGraph: new Map()

     

       224
       225
        
             },

     

       226
       226
       +
       

     

       227
       227
       +
             version: MOONLIGHT_VERSION,

     

       228
       228
       +
             branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       225
       229
        
       

     

       226
       230
        
             getConfig,

     

       227
       231
        
             getConfigOption: <T>(ext: string, name: string) => {

+12 -2

packages/node-preload/src/index.ts

···

       3
       3
        
       import path from "path";

     

       4
       4
        
       

     

       5
       5
        
       import { readConfig, writeConfig } from "@moonlight-mod/core/config";

     

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

     

       6
       6
       +
       import { constants, MoonlightBranch } from "@moonlight-mod/types";

     

       7
       7
        
       import { getExtensions } from "@moonlight-mod/core/extension";

     

       8
       8
       -
       import { getExtensionsPath } from "@moonlight-mod/core/util/data";

     

       8
       8
       +
       import {

     

       9
       9
       +
         getExtensionsPath,

     

       10
       10
       +
         getMoonlightDir

     

       11
       11
       +
       } from "@moonlight-mod/core/util/data";

     

       9
       12
        
       import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     

       10
       13
        
       import {

     

       11
       14
        
         loadExtensions,

     
···

       29
       32
        
           extensions,

     

       30
       33
        
           processedExtensions,

     

       31
       34
        
           nativesCache: {},

     

       35
       35
       +
       

     

       36
       36
       +
           version: MOONLIGHT_VERSION,

     

       37
       37
       +
           branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       38
       38
       +
       

     

       32
       39
        
           getConfig,

     

       33
       40
        
           getConfigOption: <T>(ext: string, name: string) => {

     

       34
       41
        
             const config = getConfig(ext);

     
···

       42
       49
        
             return new Logger(id);

     

       43
       50
        
           },

     

       44
       51
        
       

     

       52
       52
       +
           getMoonlightDir() {

     

       53
       53
       +
             return getMoonlightDir();

     

       54
       54
       +
           },

     

       45
       55
        
           getExtensionDir: (ext: string) => {

     

       46
       56
        
             const extPath = getExtensionsPath();

     

       47
       57
        
             return path.join(extPath, ext);

+1

packages/types/src/coreExtensions.ts

···

       2
       2
        
       export * as Settings from "./coreExtensions/settings";

     

       3
       3
        
       export * as Markdown from "./coreExtensions/markdown";

     

       4
       4
        
       export * as ContextMenu from "./coreExtensions/contextMenu";

     

       5
       5
       +
       export * as Notices from "./coreExtensions/notices";

+21

packages/types/src/coreExtensions/notices.ts

···

       1
       1
       +
       import type { Store } from "@moonlight-mod/mappings/discord/packages/flux";

     

       2
       2
       +
       

     

       3
       3
       +
       export type NoticeButton = {

     

       4
       4
       +
         name: string;

     

       5
       5
       +
         onClick: () => boolean; // return true to dismiss the notice after the button is clicked

     

       6
       6
       +
       };

     

       7
       7
       +
       

     

       8
       8
       +
       export type Notice = {

     

       9
       9
       +
         element: React.ReactNode;

     

       10
       10
       +
         color?: string;

     

       11
       11
       +
         showClose?: boolean;

     

       12
       12
       +
         buttons?: NoticeButton[];

     

       13
       13
       +
         onDismiss?: () => void;

     

       14
       14
       +
       };

     

       15
       15
       +
       

     

       16
       16
       +
       export type Notices = Store<any> & {

     

       17
       17
       +
         addNotice: (notice: Notice) => void;

     

       18
       18
       +
         popNotice: () => void;

     

       19
       19
       +
         getCurrentNotice: () => Notice | null;

     

       20
       20
       +
         shouldShowNotice: () => boolean;

     

       21
       21
       +
       };

+3

packages/types/src/discord/require.ts

···

       2
       2
        
       import { Markdown } from "../coreExtensions/markdown";

     

       3
       3
        
       import { Settings } from "../coreExtensions/settings";

     

       4
       4
        
       import { Spacepack } from "../coreExtensions/spacepack";

     

       5
       5
       +
       import { Notices } from "../coreExtensions/notices";

     

       5
       6
        
       

     

       6
       7
        
       declare function WebpackRequire(id: string): any;

     

       7
       8
        
       

     
···

       9
       10
        
       declare function WebpackRequire(id: "contextMenu_contextMenu"): ContextMenu;

     

       10
       11
        
       

     

       11
       12
        
       declare function WebpackRequire(id: "markdown_markdown"): Markdown;

     

       13
       13
       +
       

     

       14
       14
       +
       declare function WebpackRequire(id: "notices_notices"): Notices;

     

       12
       15
        
       

     

       13
       16
        
       declare function WebpackRequire(id: "settings_settings"): {

     

       14
       17
        
         Settings: Settings;

+7 -5

packages/types/src/discord/webpack.ts

···

       1
       1
        
       import WebpackRequire from "./require";

     

       2
       2
       +
       import { WebpackRequire as MappingsWebpackRequire } from "@moonlight-mod/mappings";

     

       2
       3
        
       

     

       3
       3
       -
       export type WebpackRequireType = typeof WebpackRequire & {

     

       4
       4
       -
         c: Record<string, WebpackModule>;

     

       5
       5
       -
         m: Record<string, WebpackModuleFunc>;

     

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

     

       7
       7
       -
       };

     

       4
       4
       +
       export type WebpackRequireType = typeof MappingsWebpackRequire &

     

       5
       5
       +
         typeof WebpackRequire & {

     

       6
       6
       +
           c: Record<string, WebpackModule>;

     

       7
       7
       +
           m: Record<string, WebpackModuleFunc>;

     

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

     

       9
       9
       +
         };

     

       8
       10
        
       

     

       9
       11
        
       export type WebpackModule = {

     

       10
       12
        
         id: string | number;

+16

packages/types/src/globals.ts

···

       18
       18
        
         extensions: DetectedExtension[];

     

       19
       19
        
         processedExtensions: ProcessedExtensions;

     

       20
       20
        
       

     

       21
       21
       +
         version: string;

     

       22
       22
       +
         branch: MoonlightBranch;

     

       23
       23
       +
       

     

       21
       24
        
         getConfig: (ext: string) => ConfigExtension["config"];

     

       22
       25
        
         getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       23
       26
        
         getLogger: (id: string) => Logger;

     
···

       29
       32
        
         processedExtensions: ProcessedExtensions;

     

       30
       33
        
         nativesCache: Record<string, any>;

     

       31
       34
        
       

     

       35
       35
       +
         version: string;

     

       36
       36
       +
         branch: MoonlightBranch;

     

       37
       37
       +
       

     

       32
       38
        
         getConfig: (ext: string) => ConfigExtension["config"];

     

       33
       39
        
         getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       34
       40
        
         getNatives: (ext: string) => any | undefined;

     

       35
       41
        
         getLogger: (id: string) => Logger;

     

       36
       42
        
       

     

       43
       43
       +
         getMoonlightDir: () => string;

     

       37
       44
        
         getExtensionDir: (ext: string) => string;

     

       38
       45
        
         writeConfig: (config: Config) => void;

     

       39
       46
        
       };

     
···

       70
       77
        
           registerWebpackModule: (module: IdentifiedWebpackModule) => void;

     

       71
       78
        
         };

     

       72
       79
        
       

     

       80
       80
       +
         version: string;

     

       81
       81
       +
         branch: MoonlightBranch;

     

       82
       82
       +
       

     

       73
       83
        
         getConfig: (ext: string) => ConfigExtension["config"];

     

       74
       84
        
         getConfigOption: <T>(ext: string, name: string) => T | undefined;

     

       75
       85
        
         getNatives: (ext: string) => any | undefined;

     
···

       83
       93
        
         NodePreload = "node-preload",

     

       84
       94
        
         WebPreload = "web-preload"

     

       85
       95
        
       }

     

       96
       96
       +
       

     

       97
       97
       +
       export enum MoonlightBranch {

     

       98
       98
       +
         STABLE = "stable",

     

       99
       99
       +
         NIGHTLY = "nightly",

     

       100
       100
       +
         DEV = "dev"

     

       101
       101
       +
       }

+6

packages/types/src/import.d.ts

···

       17
       17
        
         export = Markdown;

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
       +
       declare module "@moonlight-mod/wp/notices_notices" {

     

       21
       21
       +
         import { CoreExtensions } from "@moonlight-mod/types";

     

       22
       22
       +
         const Notices: CoreExtensions.Notices.Notices;

     

       23
       23
       +
         export = Notices;

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       20
       26
        
       declare module "@moonlight-mod/wp/settings_settings" {

     

       21
       27
        
         import { CoreExtensions } from "@moonlight-mod/types";

     

       22
       28
        
         export const Settings: CoreExtensions.Settings.Settings;

+2

packages/types/src/index.ts

···

       30
       30
        
         const MOONLIGHT_NODE_PRELOAD: boolean;

     

       31
       31
        
         const MOONLIGHT_WEB_PRELOAD: boolean;

     

       32
       32
        
         const MOONLIGHT_BROWSER: boolean;

     

       33
       33
       +
         const MOONLIGHT_BRANCH: string;

     

       34
       34
       +
         const MOONLIGHT_VERSION: string;

     

       33
       35
        
       

     

       34
       36
        
         var moonlightHost: MoonlightHost;

     

       35
       37
        
         var moonlightNode: MoonlightNode;

+10 -3

packages/web-preload/src/index.ts

···

       5
       5
        
         registerPatch,

     

       6
       6
        
         registerWebpackModule

     

       7
       7
        
       } from "@moonlight-mod/core/patch";

     

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

     

       8
       8
       +
       import { constants, MoonlightBranch } from "@moonlight-mod/types";

     

       9
       9
        
       import { installStyles } from "@moonlight-mod/core/styles";

     

       10
       10
        
       import Logger, { initLogger } from "@moonlight-mod/core/util/logger";

     

       11
       11
        
       import LunAST from "@moonlight-mod/lunast";

     
···

       30
       30
        
             registerWebpackModule

     

       31
       31
        
           },

     

       32
       32
        
       

     

       33
       33
       +
           version: MOONLIGHT_VERSION,

     

       34
       34
       +
           branch: MOONLIGHT_BRANCH as MoonlightBranch,

     

       35
       35
       +
       

     

       33
       36
        
           getConfig: moonlightNode.getConfig.bind(moonlightNode),

     

       34
       37
        
           getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),

     

       35
       38
        
           getNatives: moonlightNode.getNatives.bind(moonlightNode),

     
···

       48
       51
        
           logger.error("Error setting up web-preload", e);

     

       49
       52
        
         }

     

       50
       53
        
       

     

       51
       51
       -
         window.addEventListener("DOMContentLoaded", () => {

     

       54
       54
       +
         if (MOONLIGHT_ENV === "web-preload") {

     

       55
       55
       +
           window.addEventListener("DOMContentLoaded", () => {

     

       56
       56
       +
             installStyles();

     

       57
       57
       +
           });

     

       58
       58
       +
         } else {

     

       52
       59
        
           installStyles();

     

       53
       53
       -
         });

     

       60
       60
       +
         }

     

       54
       61
        
       }

     

       55
       62
        
       

     

       56
       63
        
       if (MOONLIGHT_ENV === "web-preload") {

+1

pnpm-lock.yaml

···

       672
       672
        
         eslint@8.55.0:

     

       673
       673
        
           resolution: {integrity: sha512-iyUUAM0PCKj5QpwGfmCAG9XXbZCWsqP/eWAWrG/W0umvjuLRBECwSFdt+rCntju0xEH7teIABPwXpahftIaTdA==}

     

       674
       674
        
           engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}

     

       675
       675
       +
           deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options.

     

       675
       676
        
           hasBin: true

     

       676
       677
        
       

     

       677
       678
        
         espree@9.6.1: