commit 13c46c9e7f34b6270ff3a2fff7b08b57bfa575e2 · notnite.com/moonlight

+2 -1

packages/core-extensions/package.json

···

       3
       3
        
         "private": true,

     

       4
       4
        
         "dependencies": {

     

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

     

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

     

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

     

       7
       7
       +
           "nanotar": "^0.1.1"

     

       7
       8
        
         }

     

       8
       9
        
       }

+48 -3

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

···

       45
       45
        
         }

     

       46
       46
        
       };

     

       47
       47
        
       

     

       48
       48
       +
       const bg = "#222034";

     

       49
       49
       +
       const fg = "#FFFBA6";

     

       50
       50
       +
       

     

       48
       51
        
       export const styles = [

     

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

     

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

     

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

     

       52
       52
       +
         `

     

       53
       53
       +
       .moonbase-settings > :first-child {

     

       54
       54
       +
         margin-top: 0px;

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       textarea.moonbase-resizeable {

     

       58
       58
       +
         resize: vertical

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       .moonbase-updates-notice {

     

       62
       62
       +
         background-color: ${bg};

     

       63
       63
       +
         color: ${fg};

     

       64
       64
       +
         line-height: unset;

     

       65
       65
       +
         height: 36px;

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       .moonbase-updates-notice button {

     

       69
       69
       +
         color: ${fg};

     

       70
       70
       +
         border-color: ${fg};

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       73
       73
       +
       .moonbase-updates-notice_text-wrapper {

     

       74
       74
       +
         display: inline-flex;

     

       75
       75
       +
         align-items: center;

     

       76
       76
       +
         line-height: 36px;

     

       77
       77
       +
         gap: 2px;

     

       78
       78
       +
       }

     

       79
       79
       +
       

     

       80
       80
       +
       .moonbase-update-section {

     

       81
       81
       +
         background-color: ${bg};

     

       82
       82
       +
         --info-help-foreground: ${fg};

     

       83
       83
       +
         border: none !important;

     

       84
       84
       +
         color: ${fg};

     

       85
       85
       +
       

     

       86
       86
       +
         display: flex;

     

       87
       87
       +
         flex-direction: row;

     

       88
       88
       +
         justify-content: space-between;

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       .moonbase-update-section > button {

     

       92
       92
       +
         color: ${fg};

     

       93
       93
       +
         background-color: transparent;

     

       94
       94
       +
         border-color: ${fg};

     

       95
       95
       +
       }

     

       96
       96
       +
       `.trim()

     

       52
       97
        
       ];

+18 -2

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

···

       4
       4
        
         "meta": {

     

       5
       5
        
           "name": "Moonbase",

     

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

     

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

     

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

     

       8
       8
        
         },

     

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

     

       10
       10
        
         "settings": {

     
···

       17
       17
        
             "displayName": "Persist filter",

     

       18
       18
        
             "description": "Save extension filter in config",

     

       19
       19
        
             "type": "boolean"

     

       20
       20
       +
           },

     

       21
       21
       +
           "updateChecking": {

     

       22
       22
       +
             "displayName": "Automatic update checking",

     

       23
       23
       +
             "description": "Checks for updates to moonlight",

     

       24
       24
       +
             "type": "boolean",

     

       25
       25
       +
             "default": "true"

     

       26
       26
       +
           },

     

       27
       27
       +
           "updateBanner": {

     

       28
       28
       +
             "displayName": "Show update banner",

     

       29
       29
       +
             "description": "Shows a banner for moonlight and extension updates",

     

       30
       30
       +
             "type": "boolean",

     

       31
       31
       +
             "default": "true"

     

       20
       32
        
           }

     

       21
       21
       -
         }

     

       33
       33
       +
         },

     

       34
       34
       +
         "cors": [

     

       35
       35
       +
           "https://github.com/moonlight-mod/moonlight/releases/download/",

     

       36
       36
       +
           "https://objects.githubusercontent.com/github-production-release-asset-"

     

       37
       37
       +
         ]

     

       22
       38
        
       }

+109 -13

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

···

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

     

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

     

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

     

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

     

       4
       4
       +
       import {

     

       5
       5
       +
         distDir,

     

       6
       6
       +
         repoUrlFile,

     

       7
       7
       +
         installedVersionFile

     

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

     

       9
       9
       +
       import { parseTarGzip } from "nanotar";

     

       5
       10
        
       

     

       6
       6
       -
       export const githubRepo = "moonlight-mod/moonlight";

     

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

     

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

     

       12
       12
       +
       const githubApiUrl = `https://api.github.com/repos/${githubRepo}/releases/latest`;

     

       13
       13
       +
       const artifactName = "dist.tar.gz";

     

       14
       14
       +
       

     

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

     

       16
       16
       +
       const nightlyZipUrl = "https://moonlight-mod.github.io/moonlight/dist.tar.gz";

     

       17
       17
       +
       

     

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

     

       9
       19
        
       

     

       20
       20
       +
       async function getStableRelease(): Promise<{

     

       21
       21
       +
         name: string;

     

       22
       22
       +
         assets: {

     

       23
       23
       +
           name: string;

     

       24
       24
       +
           browser_download_url: string;

     

       25
       25
       +
         }[];

     

       26
       26
       +
       }> {

     

       27
       27
       +
         const req = await fetch(githubApiUrl, {

     

       28
       28
       +
           cache: "no-store",

     

       29
       29
       +
           headers: {

     

       30
       30
       +
             "User-Agent": userAgent

     

       31
       31
       +
           }

     

       32
       32
       +
         });

     

       33
       33
       +
         return await req.json();

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       10
       36
        
       export default function getNatives(): MoonbaseNatives {

     

       11
       37
        
         const logger = moonlightNode.getLogger("moonbase/natives");

     

       12
       38
        
       

     
···

       14
       40
        
           async checkForMoonlightUpdate() {

     

       15
       41
        
             try {

     

       16
       42
        
               if (moonlightNode.branch === MoonlightBranch.STABLE) {

     

       17
       17
       -
                 const req = await fetch(

     

       18
       18
       -
                   `https://api.github.com/repos/${githubRepo}/releases/latest?_=${Date.now()}`,

     

       19
       19
       -
                   {

     

       20
       20
       -
                     headers: {

     

       21
       21
       -
                       "User-Agent": userAgent

     

       22
       22
       -
                     }

     

       23
       23
       -
                   }

     

       24
       24
       -
                 );

     

       25
       25
       -
                 const json: { name: string } = await req.json();

     

       43
       43
       +
                 const json = await getStableRelease();

     

       26
       44
        
                 return json.name !== moonlightNode.version ? json.name : null;

     

       27
       45
        
               } else if (moonlightNode.branch === MoonlightBranch.NIGHTLY) {

     

       28
       28
       -
                 const req = await fetch(`${nightlyRefUrl}?_=${Date.now()}`, {

     

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

     

       47
       47
       +
                   cache: "no-store",

     

       29
       48
        
                   headers: {

     

       30
       49
        
                     "User-Agent": userAgent

     

       31
       50
        
                   }

     
···

       41
       60
        
             }

     

       42
       61
        
           },

     

       43
       62
        
       

     

       63
       63
       +
           async updateMoonlight() {

     

       64
       64
       +
             // Note: this won't do anything on browser, we should probably disable it

     

       65
       65
       +
             // entirely when running in browser.

     

       66
       66
       +
             async function downloadStable(): Promise<[ArrayBuffer, string]> {

     

       67
       67
       +
               const json = await getStableRelease();

     

       68
       68
       +
               const asset = json.assets.find((a) => a.name === artifactName);

     

       69
       69
       +
               if (!asset) throw new Error("Artifact not found");

     

       70
       70
       +
       

     

       71
       71
       +
               logger.debug(`Downloading ${asset.browser_download_url}`);

     

       72
       72
       +
               const req = await fetch(asset.browser_download_url, {

     

       73
       73
       +
                 cache: "no-store",

     

       74
       74
       +
                 headers: {

     

       75
       75
       +
                   "User-Agent": userAgent

     

       76
       76
       +
                 }

     

       77
       77
       +
               });

     

       78
       78
       +
       

     

       79
       79
       +
               return [await req.arrayBuffer(), json.name];

     

       80
       80
       +
             }

     

       81
       81
       +
       

     

       82
       82
       +
             async function downloadNightly(): Promise<[ArrayBuffer, string]> {

     

       83
       83
       +
               logger.debug(`Downloading ${nightlyZipUrl}`);

     

       84
       84
       +
               const zipReq = await fetch(nightlyZipUrl, {

     

       85
       85
       +
                 cache: "no-store",

     

       86
       86
       +
                 headers: {

     

       87
       87
       +
                   "User-Agent": userAgent

     

       88
       88
       +
                 }

     

       89
       89
       +
               });

     

       90
       90
       +
       

     

       91
       91
       +
               const refReq = await fetch(nightlyRefUrl, {

     

       92
       92
       +
                 cache: "no-store",

     

       93
       93
       +
                 headers: {

     

       94
       94
       +
                   "User-Agent": userAgent

     

       95
       95
       +
                 }

     

       96
       96
       +
               });

     

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

     

       98
       98
       +
       

     

       99
       99
       +
               return [await zipReq.arrayBuffer(), ref];

     

       100
       100
       +
             }

     

       101
       101
       +
       

     

       102
       102
       +
             const [tar, ref] =

     

       103
       103
       +
               moonlightNode.branch === MoonlightBranch.STABLE

     

       104
       104
       +
                 ? await downloadStable()

     

       105
       105
       +
                 : moonlightNode.branch === MoonlightBranch.NIGHTLY

     

       106
       106
       +
                   ? await downloadNightly()

     

       107
       107
       +
                   : [null, null];

     

       108
       108
       +
       

     

       109
       109
       +
             if (!tar || !ref) return;

     

       110
       110
       +
       

     

       111
       111
       +
             const dist = moonlightFS.join(moonlightNode.getMoonlightDir(), distDir);

     

       112
       112
       +
             if (await moonlightFS.exists(dist)) await moonlightFS.rmdir(dist);

     

       113
       113
       +
             await moonlightFS.mkdir(dist);

     

       114
       114
       +
       

     

       115
       115
       +
             logger.debug("Extracting update");

     

       116
       116
       +
             const files = await parseTarGzip(tar);

     

       117
       117
       +
             for (const file of files) {

     

       118
       118
       +
               if (!file.data) continue;

     

       119
       119
       +
               // @ts-expect-error What do you mean their own types are wrong

     

       120
       120
       +
               if (file.type !== "file") continue;

     

       121
       121
       +
       

     

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

     

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

     

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

     

       125
       125
       +
                 await moonlightFS.mkdir(fullDir);

     

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

     

       127
       127
       +
             }

     

       128
       128
       +
       

     

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

     

       130
       130
       +
             const versionFile = moonlightFS.join(

     

       131
       131
       +
               moonlightNode.getMoonlightDir(),

     

       132
       132
       +
               installedVersionFile

     

       133
       133
       +
             );

     

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

     

       135
       135
       +
       

     

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

     

       137
       137
       +
           },

     

       138
       138
       +
       

     

       44
       139
        
           async fetchRepositories(repos) {

     

       45
       140
        
             const ret: Record<string, RepositoryManifest[]> = {};

     

       46
       141
        
       

     

       47
       142
        
             for (const repo of repos) {

     

       48
       143
        
               try {

     

       49
       144
        
                 const req = await fetch(repo, {

     

       145
       145
       +
                   cache: "no-store",

     

       50
       146
        
                   headers: {

     

       51
       147
        
                     "User-Agent": userAgent

     

       52
       148
        
                   }

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

···

       3
       3
        
       

     

       4
       4
        
       export type MoonbaseNatives = {

     

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

     

       6
       6
       +
         updateMoonlight(): Promise<void>;

     

       7
       7
       +
       

     

       6
       8
        
         fetchRepositories(

     

       7
       9
        
           repos: string[]

     

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

+78 -14

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

···

       4
       4
        
       import { Moonbase, pages } from "@moonlight-mod/wp/moonbase_ui";

     

       5
       5
        
       

     

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

     

       7
       7
       -
       import { MenuItem } from "@moonlight-mod/wp/discord/components/common/index";

     

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

     

       8
       8
       +
       

     

       9
       9
       +
       const { MenuItem, Text, Breadcrumbs } = Components;

     

       10
       10
       +
       

     

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

     

       8
       12
        
       

     

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

     

       10
       14
        
         .exports.Z;

     

       11
       15
        
       

     

       12
       12
       -
       settings.addSection("moonbase", "Moonbase", Moonbase, null, -2, {

     

       16
       16
       +
       const notice = {

     

       13
       17
        
         stores: [MoonbaseSettingsStore],

     

       14
       18
        
         element: () => {

     

       15
       19
        
           // Require it here because lazy loading SUX

     
···

       29
       33
        
             />

     

       30
       34
        
           );

     

       31
       35
        
         }

     

       32
       32
       -
       });

     

       36
       36
       +
       };

     

       33
       37
        
       

     

       34
       34
       -
       settings.addSectionMenuItems(

     

       35
       35
       -
         "moonbase",

     

       36
       36
       -
         ...pages.map((page, i) => (

     

       37
       37
       -
           <MenuItem

     

       38
       38
       -
             key={page.id}

     

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

     

       40
       40
       -
             label={page.name}

     

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

     

       42
       42
       -
           />

     

       43
       43
       -
         ))

     

       44
       44
       -
       );

     

       38
       38
       +
       function addSection(

     

       39
       39
       +
         id: string,

     

       40
       40
       +
         name: string,

     

       41
       41
       +
         element: React.FunctionComponent

     

       42
       42
       +
       ) {

     

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

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       // FIXME: move to component types

     

       47
       47
       +
       type Breadcrumb = {

     

       48
       48
       +
         id: string;

     

       49
       49
       +
         label: string;

     

       50
       50
       +
       };

     

       51
       51
       +
       

     

       52
       52
       +
       function renderBreadcrumb(crumb: Breadcrumb, last: boolean) {

     

       53
       53
       +
         return (

     

       54
       54
       +
           <Text

     

       55
       55
       +
             variant="heading-lg/semibold"

     

       56
       56
       +
             tag="h2"

     

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

     

       58
       58
       +
           >

     

       59
       59
       +
             {crumb.label}

     

       60
       60
       +
           </Text>

     

       61
       61
       +
         );

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       64
       64
       +
       if (

     

       65
       65
       +
         MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       66
       66
       +
           "moonbase",

     

       67
       67
       +
           "sections",

     

       68
       68
       +
           false

     

       69
       69
       +
         )

     

       70
       70
       +
       ) {

     

       71
       71
       +
         settings.addHeader("Moonbase", -2);

     

       72
       72
       +
       

     

       73
       73
       +
         for (const page of pages) {

     

       74
       74
       +
           addSection(page.id, page.name, () => {

     

       75
       75
       +
             const breadcrumbs = [

     

       76
       76
       +
               { id: "moonbase", label: "Moonbase" },

     

       77
       77
       +
               { id: page.id, label: page.name }

     

       78
       78
       +
             ];

     

       79
       79
       +
             return (

     

       80
       80
       +
               <>

     

       81
       81
       +
                 <Breadcrumbs

     

       82
       82
       +
                   className={Margins.marginBottom20}

     

       83
       83
       +
                   renderCustomBreadcrumb={renderBreadcrumb}

     

       84
       84
       +
                   breadcrumbs={breadcrumbs}

     

       85
       85
       +
                   activeId={page.id}

     

       86
       86
       +
                 >

     

       87
       87
       +
                   {page.name}

     

       88
       88
       +
                 </Breadcrumbs>

     

       89
       89
       +
                 <page.element />

     

       90
       90
       +
               </>

     

       91
       91
       +
             );

     

       92
       92
       +
           });

     

       93
       93
       +
         }

     

       94
       94
       +
       } else {

     

       95
       95
       +
         settings.addSection("moonbase", "Moonbase", Moonbase, null, -2, notice);

     

       96
       96
       +
       

     

       97
       97
       +
         settings.addSectionMenuItems(

     

       98
       98
       +
           "moonbase",

     

       99
       99
       +
           ...pages.map((page, i) => (

     

       100
       100
       +
             <MenuItem

     

       101
       101
       +
               key={page.id}

     

       102
       102
       +
               id={`moonbase-${page.id}`}

     

       103
       103
       +
               label={page.name}

     

       104
       104
       +
               action={() => open("moonbase", i)}

     

       105
       105
       +
             />

     

       106
       106
       +
           ))

     

       107
       107
       +
         );

     

       108
       108
       +
       }

+23 -5

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

···

       124
       124
        
       

     

       125
       125
        
               this.emitChange();

     

       126
       126
        
             })

     

       127
       127
       -
             .then(natives!.checkForMoonlightUpdate)

     

       127
       127
       +
             .then(() =>

     

       128
       128
       +
               this.getExtensionConfigRaw("moonbase", "updateChecking", true)

     

       129
       129
       +
                 ? natives!.checkForMoonlightUpdate()

     

       130
       130
       +
                 : new Promise<null>((resolve) => resolve(null))

     

       131
       131
       +
             )

     

       128
       132
        
             .then((version) => {

     

       129
       133
        
               this.newVersion = version;

     

       130
       134
        
               this.emitChange();

     
···

       216
       220
        
           return cfg.config?.[key] ?? clonedDefaultValue;

     

       217
       221
        
         }

     

       218
       222
        
       

     

       223
       223
       +
         getExtensionConfigRaw<T>(

     

       224
       224
       +
           id: string,

     

       225
       225
       +
           key: string,

     

       226
       226
       +
           defaultValue: T | undefined

     

       227
       227
       +
         ): T | undefined {

     

       228
       228
       +
           const cfg = this.config.extensions[id];

     

       229
       229
       +
       

     

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

     

       231
       231
       +
           return cfg.config?.[key] ?? defaultValue;

     

       232
       232
       +
         }

     

       233
       233
       +
       

     

       219
       234
        
         getExtensionConfigName(uniqueId: number, key: string) {

     

       220
       235
        
           const ext = this.getExtension(uniqueId);

     

       221
       236
        
           return ext.manifest.settings?.[key]?.displayName ?? key;

     
···

       226
       241
        
           return ext.manifest.settings?.[key]?.description;

     

       227
       242
        
         }

     

       228
       243
        
       

     

       229
       229
       -
         setExtensionConfig(uniqueId: number, key: string, value: any) {

     

       230
       230
       -
           const ext = this.getExtension(uniqueId);

     

       231
       231
       -
           const oldConfig = this.config.extensions[ext.id];

     

       244
       244
       +
         setExtensionConfig(id: string, key: string, value: any) {

     

       245
       245
       +
           const oldConfig = this.config.extensions[id];

     

       232
       246
        
           const newConfig =

     

       233
       247
        
             typeof oldConfig === "boolean"

     

       234
       248
        
               ? {

     
···

       240
       254
        
                   config: { ...(oldConfig?.config ?? {}), [key]: value }

     

       241
       255
        
                 };

     

       242
       256
        
       

     

       243
       243
       -
           this.config.extensions[ext.id] = newConfig;

     

       257
       257
       +
           this.config.extensions[id] = newConfig;

     

       244
       258
        
           this.modified = this.isModified();

     

       245
       259
        
           this.emitChange();

     

       246
       260
        
         }

     
···

       354
       368
        
       

     

       355
       369
        
           this.installing = false;

     

       356
       370
        
           this.emitChange();

     

       371
       371
       +
         }

     

       372
       372
       +
       

     

       373
       373
       +
         async updateMoonlight() {

     

       374
       374
       +
           await natives.updateMoonlight();

     

       357
       375
        
         }

     

       358
       376
        
       

     

       359
       377
        
         getConfigOption<K extends keyof Config>(key: K): Config[K] {

+18

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

···

       121
       121
        
       export default function ConfigPage() {

     

       122
       122
        
         return (

     

       123
       123
        
           <>

     

       124
       124
       +
             <FormSwitch

     

       125
       125
       +
               className={Margins.marginTop20}

     

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

     

       127
       127
       +
                 "moonbase",

     

       128
       128
       +
                 "updateChecking",

     

       129
       129
       +
                 true

     

       130
       130
       +
               )}

     

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

     

       132
       132
       +
                 MoonbaseSettingsStore.setExtensionConfig(

     

       133
       133
       +
                   "moonbase",

     

       134
       134
       +
                   "updateChecking",

     

       135
       135
       +
                   value

     

       136
       136
       +
                 );

     

       137
       137
       +
               }}

     

       138
       138
       +
               note="Checks for updates to moonlight"

     

       139
       139
       +
             >

     

       140
       140
       +
               Automatic update checking

     

       141
       141
       +
             </FormSwitch>

     

       124
       142
        
             <FormItem title="Repositories">

     

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

     

       126
       144
        
                 A list of remote repositories to display extensions from

+12 -6

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

···

       15
       15
        
       )[0];

     

       16
       16
        
       

     

       17
       17
        
       export default function ExtensionsPage() {

     

       18
       18
       -
         const moonbaseId = MoonbaseSettingsStore.getExtensionUniqueId("moonbase")!;

     

       19
       18
        
         const { extensions, savedFilter } = useStateFromStoresObject(

     

       20
       19
        
           [MoonbaseSettingsStore],

     

       21
       20
        
           () => {

     

       22
       21
        
             return {

     

       23
       22
        
               extensions: MoonbaseSettingsStore.extensions,

     

       24
       24
       -
               savedFilter: MoonbaseSettingsStore.getExtensionConfig(

     

       25
       25
       -
                 moonbaseId,

     

       26
       26
       -
                 "filter"

     

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

     

       24
       24
       +
                 "moonbase",

     

       25
       25
       +
                 "filter",

     

       26
       26
       +
                 defaultFilter

     

       27
       27
        
               )

     

       28
       28
        
             };

     

       29
       29
        
           }

     
···

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

     

       33
       33
        
       

     

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

     

       35
       35
       -
         if (moonlight.getConfigOption<boolean>("moonbase", "saveFilter")) {

     

       35
       35
       +
         if (

     

       36
       36
       +
           MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       37
       37
       +
             "moonbase",

     

       38
       38
       +
             "saveFilter",

     

       39
       39
       +
             false

     

       40
       40
       +
           )

     

       41
       41
       +
         ) {

     

       36
       42
        
           filter = savedFilter ?? defaultFilter;

     

       37
       43
        
           setFilter = (filter) =>

     

       38
       38
       -
             MoonbaseSettingsStore.setExtensionConfig(moonbaseId, "filter", filter);

     

       44
       44
       +
             MoonbaseSettingsStore.setExtensionConfig("moonbase", "filter", filter);

     

       39
       45
        
         } else {

     

       40
       46
        
           const state = React.useState(defaultFilter);

     

       41
       47
        
           filter = state[0];

+8 -8

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

···

       60
       60
        
             hideBorder={true}

     

       61
       61
        
             disabled={disabled}

     

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

     

       63
       63
       -
               MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       63
       63
       +
               MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       64
       64
        
             }}

     

       65
       65
        
             note={description}

     

       66
       66
        
             className={`${Margins.marginReset} ${Margins.marginTop20}`}

     
···

       91
       91
        
               maxValue={castedSetting.max ?? 100}

     

       92
       92
        
               onValueChange={(value: number) => {

     

       93
       93
        
                 const rounded = Math.max(min, Math.min(max, Math.round(value)));

     

       94
       94
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, rounded);

     

       94
       94
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, rounded);

     

       95
       95
        
               }}

     

       96
       96
        
             />

     

       97
       97
        
           </FormItem>

     
···

       114
       114
        
               value={value ?? ""}

     

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

     

       116
       116
        
                 if (disabled) return;

     

       117
       117
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       117
       117
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       118
       118
        
               }}

     

       119
       119
        
             />

     

       120
       120
        
           </FormItem>

     
···

       139
       139
        
               className={"moonbase-resizeable"}

     

       140
       140
        
               onChange={(value: string) => {

     

       141
       141
        
                 if (disabled) return;

     

       142
       142
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       142
       142
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       143
       143
        
               }}

     

       144
       144
        
             />

     

       145
       145
        
           </FormItem>

     
···

       170
       170
        
               )}

     

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

     

       172
       172
        
                 if (disabled) return;

     

       173
       173
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

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

     

       174
       174
        
               }}

     

       175
       175
        
             />

     

       176
       176
        
           </FormItem>

     
···

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

     

       207
       207
        
                   if (disabled) return;

     

       208
       208
        
                   MoonbaseSettingsStore.setExtensionConfig(

     

       209
       209
       -
                     ext.uniqueId,

     

       209
       209
       +
                     ext.id,

     

       210
       210
        
                     name,

     

       211
       211
        
                     Array.from(value)

     

       212
       212
        
                   );

     
···

       257
       257
        
       

     

       258
       258
        
         const entries = value ?? [];

     

       259
       259
        
         const updateConfig = () =>

     

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

     

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

     

       261
       261
        
       

     

       262
       262
        
         return (

     

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

     
···

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

     

       324
       324
        
         const updateConfig = () =>

     

       325
       325
        
           MoonbaseSettingsStore.setExtensionConfig(

     

       326
       326
       -
             ext.uniqueId,

     

       326
       326
       +
             ext.id,

     

       327
       327
        
             name,

     

       328
       328
        
             Object.fromEntries(entries)

     

       329
       329
        
           );

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

···

       9
       9
        
       

     

       10
       10
        
       import ExtensionsPage from "./extensions";

     

       11
       11
        
       import ConfigPage from "./config";

     

       12
       12
       +
       import Update from "./update";

     

       12
       13
        
       

     

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

     

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

     
···

       81
       82
        
                 ))}

     

       82
       83
        
               </TabBar>

     

       83
       84
        
             </div>

     

       85
       85
       +
       

     

       86
       86
       +
             <Update />

     

       84
       87
        
       

     

       85
       88
        
             {React.createElement(pages[subsection].element)}

     

       86
       89
        
           </>

+84

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

···

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

     

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

     

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

     

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

     

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

     

       6
       6
       +
       import Flex from "@moonlight-mod/wp/discord/uikit/Flex";

     

       7
       7
       +
       

     

       8
       8
       +
       enum UpdateState {

     

       9
       9
       +
         Ready,

     

       10
       10
       +
         Working,

     

       11
       11
       +
         Installed,

     

       12
       12
       +
         Failed

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

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

     

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

     

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

     

       18
       18
       +
         .exports;

     

       19
       19
       +
       

     

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

     

       21
       21
       +
       

     

       22
       22
       +
       const strings: Record<UpdateState, string> = {

     

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

     

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

     

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

     

       26
       26
       +
         [UpdateState.Failed]:

     

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

     

       28
       28
       +
       };

     

       29
       29
       +
       

     

       30
       30
       +
       export default function Update() {

     

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

     

       32
       32
       +
         const { newVersion } = useStateFromStores([MoonbaseSettingsStore], () => ({

     

       33
       33
       +
           newVersion: MoonbaseSettingsStore.newVersion

     

       34
       34
       +
         }));

     

       35
       35
       +
       

     

       36
       36
       +
         if (newVersion == null) return null;

     

       37
       37
       +
       

     

       38
       38
       +
         // reimpl of HelpMessage but with a custom icon

     

       39
       39
       +
         return (

     

       40
       40
       +
           <div

     

       41
       41
       +
             className={`${Margins.marginBottom20} ${HelpMessageClasses.info} ${HelpMessageClasses.container} moonbase-update-section`}

     

       42
       42
       +
           >

     

       43
       43
       +
             <Flex direction={Flex.Direction.HORIZONTAL}>

     

       44
       44
       +
               <div

     

       45
       45
       +
                 className={HelpMessageClasses.iconDiv}

     

       46
       46
       +
                 style={{

     

       47
       47
       +
                   alignItems: "center"

     

       48
       48
       +
                 }}

     

       49
       49
       +
               >

     

       50
       50
       +
                 <ThemeDarkIcon

     

       51
       51
       +
                   size="sm"

     

       52
       52
       +
                   color="currentColor"

     

       53
       53
       +
                   className={HelpMessageClasses.icon}

     

       54
       54
       +
                 />

     

       55
       55
       +
               </div>

     

       56
       56
       +
       

     

       57
       57
       +
               <Text

     

       58
       58
       +
                 variant="text-sm/medium"

     

       59
       59
       +
                 color="currentColor"

     

       60
       60
       +
                 className={HelpMessageClasses.text}

     

       61
       61
       +
               >

     

       62
       62
       +
                 {strings[state]}

     

       63
       63
       +
               </Text>

     

       64
       64
       +
             </Flex>

     

       65
       65
       +
       

     

       66
       66
       +
             <Button

     

       67
       67
       +
               look={Button.Looks.OUTLINED}

     

       68
       68
       +
               color={Button.Colors.CUSTOM}

     

       69
       69
       +
               size={Button.Sizes.TINY}

     

       70
       70
       +
               disabled={state !== UpdateState.Ready}

     

       71
       71
       +
               onClick={() => {

     

       72
       72
       +
                 MoonbaseSettingsStore.updateMoonlight()

     

       73
       73
       +
                   .then(() => setState(UpdateState.Installed))

     

       74
       74
       +
                   .catch((e) => {

     

       75
       75
       +
                     logger.error(e);

     

       76
       76
       +
                     setState(UpdateState.Failed);

     

       77
       77
       +
                   });

     

       78
       78
       +
               }}

     

       79
       79
       +
             >

     

       80
       80
       +
               Update

     

       81
       81
       +
             </Button>

     

       82
       82
       +
           </div>

     

       83
       83
       +
         );

     

       84
       84
       +
       }

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

+107

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

···

       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
       +
       import React from "@moonlight-mod/wp/react";

     

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

     

       7
       7
       +
       

     

       8
       8
       +
       // FIXME: not indexed as importable

     

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

     

       10
       10
       +
       const UserSettingsSections = spacepack.findObjectFromKey(

     

       11
       11
       +
         Constants,

     

       12
       12
       +
         "APPEARANCE_THEME_PICKER"

     

       13
       13
       +
       );

     

       14
       14
       +
       

     

       15
       15
       +
       const { ThemeDarkIcon } = Components;

     

       16
       16
       +
       

     

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

     

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

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       function listener() {

     

       22
       22
       +
         if (

     

       23
       23
       +
           MoonbaseSettingsStore.shouldShowNotice &&

     

       24
       24
       +
           MoonbaseSettingsStore.getExtensionConfigRaw(

     

       25
       25
       +
             "moonbase",

     

       26
       26
       +
             "updateBanner",

     

       27
       27
       +
             true

     

       28
       28
       +
           )

     

       29
       29
       +
         ) {

     

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

     

       31
       31
       +
           MoonbaseSettingsStore.removeChangeListener(listener);

     

       32
       32
       +
       

     

       33
       33
       +
           const version = MoonbaseSettingsStore.newVersion;

     

       34
       34
       +
           const extensionUpdateCount = Object.keys(

     

       35
       35
       +
             MoonbaseSettingsStore.updates

     

       36
       36
       +
           ).length;

     

       37
       37
       +
           const hasExtensionUpdates = extensionUpdateCount > 0;

     

       38
       38
       +
       

     

       39
       39
       +
           let message;

     

       40
       40
       +
       

     

       41
       41
       +
           if (version != null) {

     

       42
       42
       +
             message =

     

       43
       43
       +
               moonlightNode.branch === MoonlightBranch.NIGHTLY

     

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

     

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

     

       46
       46
       +
           }

     

       47
       47
       +
       

     

       48
       48
       +
           if (hasExtensionUpdates) {

     

       49
       49
       +
             let concat = false;

     

       50
       50
       +
             if (message == null) {

     

       51
       51
       +
               message = "";

     

       52
       52
       +
             } else {

     

       53
       53
       +
               concat = true;

     

       54
       54
       +
               message += ", and ";

     

       55
       55
       +
             }

     

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

     

       57
       57
       +
               "extension",

     

       58
       58
       +
               extensionUpdateCount

     

       59
       59
       +
             )} can be updated`;

     

       60
       60
       +
           }

     

       61
       61
       +
       

     

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

     

       63
       63
       +
       

     

       64
       64
       +
           Notices.addNotice({

     

       65
       65
       +
             element: (

     

       66
       66
       +
               <div className="moonbase-updates-notice_text-wrapper">

     

       67
       67
       +
                 <ThemeDarkIcon size="sm" color="currentColor" />

     

       68
       68
       +
                 {message}

     

       69
       69
       +
               </div>

     

       70
       70
       +
             ),

     

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

     

       72
       72
       +
             buttons: [

     

       73
       73
       +
               {

     

       74
       74
       +
                 name: "Open Moonbase",

     

       75
       75
       +
                 onClick: () => {

     

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

     

       77
       77
       +
                     "setSection",

     

       78
       78
       +
                     "clearSubsection"

     

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

     

       80
       80
       +
       

     

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

     

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

     

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

     

       84
       84
       +
                   open(UserSettingsSections.ACCOUNT);

     

       85
       85
       +
                   setTimeout(() => {

     

       86
       86
       +
                     if (

     

       87
       87
       +
                       MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(

     

       88
       88
       +
                         "moonbase",

     

       89
       89
       +
                         "sections",

     

       90
       90
       +
                         false

     

       91
       91
       +
                       )

     

       92
       92
       +
                     ) {

     

       93
       93
       +
                       open("moonbase-extensions");

     

       94
       94
       +
                     } else {

     

       95
       95
       +
                       open("moonbase", 0);

     

       96
       96
       +
                     }

     

       97
       97
       +
                   }, 0);

     

       98
       98
       +
                   return true;

     

       99
       99
       +
                 }

     

       100
       100
       +
               }

     

       101
       101
       +
             ]

     

       102
       102
       +
           });

     

       103
       103
       +
         }

     

       104
       104
       +
       }

     

       105
       105
       +
       

     

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

     

       107
       107
       +
       MoonbaseSettingsStore.addChangeListener(listener);

packages/types/src/constants.ts

···

       2
       2
        
       export const distDir = "dist";

     

       3
       3
        
       export const coreExtensionsDir = "core-extensions";

     

       4
       4
        
       export const repoUrlFile = ".moonlight-repo-url";

     

       5
       5
       +
       export const installedVersionFile = ".moonlight-installed-version";

     

       5
       6
        
       

     

       6
       7
        
       export const ipcGetOldPreloadPath = "_moonlight_getOldPreloadPath";

     

       7
       8
        
       export const ipcGetAppData = "_moonlight_getAppData";

pnpm-lock.yaml

···

       74
       74
        
             '@moonlight-mod/types':

     

       75
       75
        
               specifier: workspace:*

     

       76
       76
        
               version: link:../types

     

       77
       77
       +
             nanotar:

     

       78
       78
       +
               specifier: ^0.1.1

     

       79
       79
       +
               version: 0.1.1

     

       77
       80
        
       

     

       78
       81
        
         packages/injector:

     

       79
       82
        
           dependencies:

     
···

       1077
       1080
        
       

     

       1078
       1081
        
         ms@2.1.2:

     

       1079
       1082
        
           resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}

     

       1083
       1083
       +
       

     

       1084
       1084
       +
         nanotar@0.1.1:

     

       1085
       1085
       +
           resolution: {integrity: sha512-AiJsGsSF3O0havL1BydvI4+wR76sKT+okKRwWIaK96cZUnXqH0uNBOsHlbwZq3+m2BR1VKqHDVudl3gO4mYjpQ==}

     

       1080
       1086
        
       

     

       1081
       1087
        
         natural-compare@1.4.0:

     

       1082
       1088
        
           resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}

     
···

       2484
       2490
        
             brace-expansion: 2.0.1

     

       2485
       2491
        
       

     

       2486
       2492
        
         ms@2.1.2: {}

     

       2493
       2493
       +
       

     

       2494
       2494
       +
         nanotar@0.1.1: {}

     

       2487
       2495
        
       

     

       2488
       2496
        
         natural-compare@1.4.0: {}

     

       2489
       2497