commit 194f084ee2a43be5233b5c29299308cc15fc6178 · notnite.com/moonlight

+18 -15

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 {

     

       7
       7
       -
         MoonlightBranch,

     

       8
       8
       -
         MoonlightBrowserFS,

     

       9
       9
       -
         MoonlightNode

     

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

     

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

     

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

     

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

     

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

     

       14
       10
        
       

     

       11
       11
       +
       function getParts(path: string) {

     

       12
       12
       +
         if (path.startsWith("/")) path = path.substring(1);

     

       13
       13
       +
         return path.split("/");

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       15
       16
        
       window._moonlightBrowserInit = async () => {

     

       16
       17
        
         // Set up a virtual filesystem with IndexedDB

     

       17
       18
        
         await configure({

     
···

       25
       26
        
           }

     

       26
       27
        
         });

     

       27
       28
        
       

     

       28
       28
       -
         const browserFS: MoonlightBrowserFS = {

     

       29
       29
       +
         window._moonlightBrowserFS = {

     

       29
       30
        
           async readFile(path) {

     

       30
       31
        
             return new Uint8Array(await fs.readFile(path));

     

       32
       32
       +
           },

     

       33
       33
       +
           async readFileString(path) {

     

       34
       34
       +
             const file = await this.readFile(path);

     

       35
       35
       +
             return new TextDecoder().decode(file);

     

       31
       36
        
           },

     

       32
       37
        
           async writeFile(path, data) {

     

       33
       38
        
             await fs.writeFile(path, data);

     

       34
       39
        
           },

     

       40
       40
       +
           async writeFileString(path, data) {

     

       41
       41
       +
             const file = new TextEncoder().encode(data);

     

       42
       42
       +
             await this.writeFile(path, file);

     

       43
       43
       +
           },

     

       35
       44
        
           async unlink(path) {

     

       36
       45
        
             await fs.unlink(path);

     

       37
       46
        
           },

     
···

       40
       49
        
             return await fs.readdir(path);

     

       41
       50
        
           },

     

       42
       51
        
           async mkdir(path) {

     

       43
       43
       -
             const parts = this.parts(path);

     

       52
       52
       +
             const parts = getParts(path);

     

       44
       53
        
             for (let i = 0; i < parts.length; i++) {

     

       45
       54
        
               const path = this.join(...parts.slice(0, i + 1));

     

       46
       55
        
               if (!(await this.exists(path))) await fs.mkdir(path);

     
···

       76
       85
        
             return str;

     

       77
       86
        
           },

     

       78
       87
        
           dirname(path) {

     

       79
       79
       -
             const parts = this.parts(path);

     

       88
       88
       +
             const parts = getParts(path);

     

       80
       89
        
             return "/" + parts.slice(0, parts.length - 1).join("/");

     

       81
       81
       -
           },

     

       82
       82
       -
           parts(path) {

     

       83
       83
       -
             if (path.startsWith("/")) path = path.substring(1);

     

       84
       84
       -
             return path.split("/");

     

       85
       90
        
           }

     

       86
       91
        
         };

     

       87
       87
       -
         Object.assign(window, {

     

       88
       88
       -
           _moonlightBrowserFS: browserFS

     

       89
       89
       -
         });

     

       90
       92
        
       

     

       91
       93
        
         // Actual loading begins here

     

       92
       94
        
         const config = await readConfig();

     
···

       106
       108
        
           extensions,

     

       107
       109
        
           processedExtensions,

     

       108
       110
        
           nativesCache: {},

     

       111
       111
       +
           fs: window._moonlightBrowserFS,

     

       109
       112
        
       

     

       110
       113
        
           version: MOONLIGHT_VERSION,

     

       111
       114
        
           branch: MOONLIGHT_BRANCH as MoonlightBranch,

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

+104

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

     

       5
       5
       +
       

     

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

     

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

     

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

     

       9
       9
       +
       

     

       10
       10
       +
       export default function getNatives(): MoonbaseNatives {

     

       11
       11
       +
         const fs = moonlightNode.fs;

     

       12
       12
       +
         const logger = moonlightNode.getLogger("moonbase/natives");

     

       13
       13
       +
       

     

       14
       14
       +
         return {

     

       15
       15
       +
           async checkForMoonlightUpdate() {

     

       16
       16
       +
             try {

     

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

     

       18
       18
       +
                 const req = await fetch(

     

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

     

       20
       20
       +
                   {

     

       21
       21
       +
                     headers: {

     

       22
       22
       +
                       "User-Agent": userAgent

     

       23
       23
       +
                     }

     

       24
       24
       +
                   }

     

       25
       25
       +
                 );

     

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

     

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

     

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

     

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

     

       30
       30
       +
                   headers: {

     

       31
       31
       +
                     "User-Agent": userAgent

     

       32
       32
       +
                   }

     

       33
       33
       +
                 });

     

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

     

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

     

       36
       36
       +
               }

     

       37
       37
       +
       

     

       38
       38
       +
               return null;

     

       39
       39
       +
             } catch (e) {

     

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

     

       41
       41
       +
               return null;

     

       42
       42
       +
             }

     

       43
       43
       +
           },

     

       44
       44
       +
       

     

       45
       45
       +
           async fetchRepositories(repos) {

     

       46
       46
       +
             const ret: Record<string, RepositoryManifest[]> = {};

     

       47
       47
       +
       

     

       48
       48
       +
             for (const repo of repos) {

     

       49
       49
       +
               try {

     

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

     

       51
       51
       +
                   headers: {

     

       52
       52
       +
                     "User-Agent": userAgent

     

       53
       53
       +
                   }

     

       54
       54
       +
                 });

     

       55
       55
       +
                 const json = await req.json();

     

       56
       56
       +
                 ret[repo] = json;

     

       57
       57
       +
               } catch (e) {

     

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

     

       59
       59
       +
               }

     

       60
       60
       +
             }

     

       61
       61
       +
       

     

       62
       62
       +
             return ret;

     

       63
       63
       +
           },

     

       64
       64
       +
       

     

       65
       65
       +
           async installExtension(manifest, url, repo) {

     

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

     

       67
       67
       +
               headers: {

     

       68
       68
       +
                 "User-Agent": userAgent

     

       69
       69
       +
               }

     

       70
       70
       +
             });

     

       71
       71
       +
       

     

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

     

       73
       73
       +
             // remake it in case of updates

     

       74
       74
       +
             if (await fs.exists(dir)) await fs.rmdir(dir);

     

       75
       75
       +
             await fs.mkdir(dir);

     

       76
       76
       +
       

     

       77
       77
       +
             const buffer = await req.arrayBuffer();

     

       78
       78
       +
             const files = extractAsar(buffer);

     

       79
       79
       +
             for (const [file, buf] of Object.entries(files)) {

     

       80
       80
       +
               const fullFile = fs.join(dir, file);

     

       81
       81
       +
               const fullDir = fs.dirname(fullFile);

     

       82
       82
       +
       

     

       83
       83
       +
               if (!(await fs.exists(fullDir))) await fs.mkdir(fullDir);

     

       84
       84
       +
               await fs.writeFile(fs.join(dir, file), buf);

     

       85
       85
       +
             }

     

       86
       86
       +
       

     

       87
       87
       +
             await fs.writeFileString(fs.join(dir, repoUrlFile), repo);

     

       88
       88
       +
           },

     

       89
       89
       +
       

     

       90
       90
       +
           async deleteExtension(id) {

     

       91
       91
       +
             const dir = moonlightNode.getExtensionDir(id);

     

       92
       92
       +
             await fs.rmdir(dir);

     

       93
       93
       +
           },

     

       94
       94
       +
       

     

       95
       95
       +
           getExtensionConfig(id, key) {

     

       96
       96
       +
             const config = moonlightNode.config.extensions[id];

     

       97
       97
       +
             if (typeof config === "object") {

     

       98
       98
       +
               return config.config?.[key];

     

       99
       99
       +
             }

     

       100
       100
       +
       

     

       101
       101
       +
             return undefined;

     

       102
       102
       +
           }

     

       103
       103
       +
         };

     

       104
       104
       +
       }

+2 -113

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

···

       1
       1
       -
       import { MoonbaseNatives, RepositoryManifest } from "./types";

     

       2
       2
       -
       import fs from "fs";

     

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

     

       8
       8
       -
       

     

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

     

       10
       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?_=${Date.now()}`,

     

       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}?_=${Date.now()}`, {

     

       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
       -
       

     

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

     

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

     

       43
       43
       -
       

     

       44
       44
       -
         for (const repo of repos) {

     

       45
       45
       -
           try {

     

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

     

       47
       47
       -
               headers: {

     

       48
       48
       -
                 "User-Agent": userAgent

     

       49
       49
       -
               }

     

       50
       50
       -
             });

     

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

     

       52
       52
       -
             ret[repo] = json;

     

       53
       53
       -
           } catch (e) {

     

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

     

       55
       55
       -
           }

     

       56
       56
       -
         }

     

       57
       57
       -
       

     

       58
       58
       -
         return ret;

     

       59
       59
       -
       }

     

       60
       60
       -
       

     

       61
       61
       -
       async function installExtension(

     

       62
       62
       -
         manifest: RepositoryManifest,

     

       63
       63
       -
         url: string,

     

       64
       64
       -
         repo: string

     

       65
       65
       -
       ) {

     

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

     

       67
       67
       -
           headers: {

     

       68
       68
       -
             "User-Agent": userAgent

     

       69
       69
       -
           }

     

       70
       70
       -
         });

     

       71
       71
       -
       

     

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

     

       73
       73
       -
         // remake it in case of updates

     

       74
       74
       -
         if (fs.existsSync(dir)) fs.rmdirSync(dir, { recursive: true });

     

       75
       75
       -
         fs.mkdirSync(dir, { recursive: true });

     

       76
       76
       -
       

     

       77
       77
       -
         const buffer = await req.arrayBuffer();

     

       78
       78
       -
         const files = extractAsar(buffer);

     

       79
       79
       -
         for (const [file, buf] of Object.entries(files)) {

     

       80
       80
       -
           const nodeBuf = Buffer.from(buf);

     

       81
       81
       -
           const fullFile = path.join(dir, file);

     

       82
       82
       -
           const fullDir = path.dirname(fullFile);

     

       83
       83
       -
       

     

       84
       84
       -
           if (!fs.existsSync(fullDir)) fs.mkdirSync(fullDir, { recursive: true });

     

       85
       85
       -
           fs.writeFileSync(path.join(dir, file), nodeBuf);

     

       86
       86
       -
         }

     

       87
       87
       -
       

     

       88
       88
       -
         fs.writeFileSync(path.join(dir, repoUrlFile), repo);

     

       89
       89
       -
       }

     

       90
       90
       -
       

     

       91
       91
       -
       async function deleteExtension(id: string) {

     

       92
       92
       -
         const dir = moonlightNode.getExtensionDir(id);

     

       93
       93
       -
         fs.rmdirSync(dir, { recursive: true });

     

       94
       94
       -
       }

     

       95
       95
       -
       

     

       96
       96
       -
       function getExtensionConfig(id: string, key: string): any {

     

       97
       97
       -
         const config = moonlightNode.config.extensions[id];

     

       98
       98
       -
         if (typeof config === "object") {

     

       99
       99
       -
           return config.config?.[key];

     

       100
       100
       -
         }

     

       101
       101
       -
       

     

       102
       102
       -
         return undefined;

     

       103
       103
       -
       }

     

       104
       104
       -
       

     

       105
       105
       -
       const exports: MoonbaseNatives = {

     

       106
       106
       -
         checkForMoonlightUpdate,

     

       107
       107
       -
         fetchRepositories,

     

       108
       108
       -
         installExtension,

     

       109
       109
       -
         deleteExtension,

     

       110
       110
       -
         getExtensionConfig

     

       111
       111
       -
       };

     

       112
       112
       -
       

     

       113
       113
       -
       module.exports = exports;

     

       1
       1
       +
       import getNatives from "./native";

     

       2
       2
       +
       module.exports = getNatives();

+6 -104

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

···

       1
       1
       -
       import {

     

       2
       2
       -
         Config,

     

       3
       3
       -
         ExtensionLoadSource,

     

       4
       4
       -
         MoonlightBranch

     

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

     

       6
       6
       -
       import {

     

       7
       7
       -
         ExtensionState,

     

       8
       8
       -
         MoonbaseExtension,

     

       9
       9
       -
         MoonbaseNatives,

     

       10
       10
       -
         RepositoryManifest

     

       11
       11
       -
       } from "../types";

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       17
       6
        
       

     

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

     

       19
       8
        
       

     

       20
       9
        
       let natives: MoonbaseNatives = moonlight.getNatives("moonbase");

     

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

     

       22
       22
       -
         const browserFS = window._moonlightBrowserFS!;

     

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

     

       54
       54
       -
           fetchRepositories: async (repos) => {

     

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

     

       56
       56
       -
       

     

       57
       57
       -
             for (const repo of repos) {

     

       58
       58
       -
               try {

     

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

     

       60
       60
       -
                 const json = await req.json();

     

       61
       61
       -
                 ret[repo] = json;

     

       62
       62
       -
               } catch (e) {

     

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

     

       64
       64
       -
               }

     

       65
       65
       -
             }

     

       66
       66
       -
       

     

       67
       67
       -
             return ret;

     

       68
       68
       -
           },

     

       69
       69
       -
           installExtension: async (manifest, url, repo) => {

     

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

     

       71
       71
       -
             const buffer = await req.arrayBuffer();

     

       72
       72
       -
       

     

       73
       73
       -
             if (await browserFS.exists("/extensions/" + manifest.id)) {

     

       74
       74
       -
               await browserFS.rmdir("/extensions/" + manifest.id);

     

       75
       75
       -
             }

     

       76
       76
       -
       

     

       77
       77
       -
             const files = extractAsar(buffer);

     

       78
       78
       -
             for (const [file, data] of Object.entries(files)) {

     

       79
       79
       -
               const path =

     

       80
       80
       -
                 "/extensions/" +

     

       81
       81
       -
                 manifest.id +

     

       82
       82
       -
                 (file.startsWith("/") ? file : `/${file}`);

     

       83
       83
       -
               await browserFS.mkdir(browserFS.dirname(path));

     

       84
       84
       -
               await browserFS.writeFile(path, data);

     

       85
       85
       -
             }

     

       86
       86
       -
       

     

       87
       87
       -
             await browserFS.writeFile(

     

       88
       88
       -
               `/extensions/${manifest.id}/` + repoUrlFile,

     

       89
       89
       -
               new TextEncoder().encode(repo)

     

       90
       90
       -
             );

     

       91
       91
       -
           },

     

       92
       92
       -
           deleteExtension: async (id) => {

     

       93
       93
       -
             browserFS.rmdir("/extensions/" + id);

     

       94
       94
       -
           },

     

       95
       95
       -
           getExtensionConfig: (id, key) => {

     

       96
       96
       -
             const config = moonlightNode.config.extensions[id];

     

       97
       97
       -
             if (typeof config === "object") {

     

       98
       98
       -
               return config.config?.[key];

     

       99
       99
       -
             }

     

       100
       100
       -
       

     

       101
       101
       -
             return undefined;

     

       102
       102
       -
           }

     

       103
       103
       -
         };

     

       104
       104
       -
       }

     

       10
       10
       +
       if (!natives) natives = getNatives();

     

       105
       11
        
       

     

       106
       12
        
       class MoonbaseSettingsStore extends Store<any> {

     

       107
       13
        
         private origConfig: Config;

     
···

       389
       295
        
         writeConfig() {

     

       390
       296
        
           this.submitting = true;

     

       391
       297
        
       

     

       392
       392
       -
           try {

     

       393
       393
       -
             moonlightNode.writeConfig(this.config);

     

       394
       394
       -
             this.origConfig = this.clone(this.config);

     

       395
       395
       -
           } catch (e) {

     

       396
       396
       -
             logger.error("Error writing config", e);

     

       397
       397
       -
           }

     

       298
       298
       +
           moonlightNode.writeConfig(this.config);

     

       299
       299
       +
           this.origConfig = this.clone(this.config);

     

       398
       300
        
       

     

       399
       301
        
           this.submitting = false;

     

       400
       302
        
           this.modified = false;

+26 -43

packages/core/src/config.ts

···

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

     

       2
       2
       -
       import requireImport from "./util/import";

     

       3
       2
        
       import { getConfigPath } from "./util/data";

     

       3
       3
       +
       import getFS from "./fs";

     

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

     

       5
       5
       +
       

     

       6
       6
       +
       const logger = new Logger("core/config");

     

       4
       7
        
       

     

       5
       8
        
       const defaultConfig: Config = {

     

       6
       9
        
         extensions: {

     
···

       12
       15
        
         repositories: ["https://moonlight-mod.github.io/extensions-dist/repo.json"]

     

       13
       16
        
       };

     

       14
       17
        
       

     

       15
       15
       -
       export function writeConfig(config: Config) {

     

       16
       16
       -
         browser: {

     

       17
       17
       -
           const enc = new TextEncoder().encode(JSON.stringify(config, null, 2));

     

       18
       18
       -
           window._moonlightBrowserFS!.writeFile("/config.json", enc);

     

       19
       19
       -
           return;

     

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

     

       19
       19
       +
         try {

     

       20
       20
       +
           const fs = getFS();

     

       21
       21
       +
           const configPath = await getConfigPath();

     

       22
       22
       +
           await fs.writeFileString(configPath, JSON.stringify(config, null, 2));

     

       23
       23
       +
         } catch (e) {

     

       24
       24
       +
           logger.error("Failed to write config", e);

     

       20
       25
        
         }

     

       21
       21
       -
       

     

       22
       22
       -
         nodeTarget: {

     

       23
       23
       -
           const fs = requireImport("fs");

     

       24
       24
       -
           const configPath = getConfigPath();

     

       25
       25
       -
           fs.writeFileSync(configPath, JSON.stringify(config, null, 2));

     

       26
       26
       -
           return;

     

       27
       27
       -
         }

     

       28
       28
       -
       

     

       29
       29
       -
         throw new Error("Called writeConfig() in an impossible environment");

     

       30
       26
        
       }

     

       31
       27
        
       

     

       32
       28
        
       export async function readConfig(): Promise<Config> {

     
···

       34
       30
        
           return moonlightNode.config;

     

       35
       31
        
         }

     

       36
       32
        
       

     

       37
       37
       -
         browser: {

     

       38
       38
       -
           if (await window._moonlightBrowserFS!.exists("/config.json")) {

     

       39
       39
       -
             const file = await window._moonlightBrowserFS!.readFile("/config.json");

     

       40
       40
       -
             const configStr = new TextDecoder().decode(file);

     

       41
       41
       -
             let config: Config = JSON.parse(configStr);

     

       33
       33
       +
         const fs = getFS();

     

       42
       34
        
       

     

       35
       35
       +
         const configPath = await getConfigPath();

     

       36
       36
       +
         if (!(await fs.exists(configPath))) {

     

       37
       37
       +
           await writeConfig(defaultConfig);

     

       38
       38
       +
           return defaultConfig;

     

       39
       39
       +
         } else {

     

       40
       40
       +
           try {

     

       41
       41
       +
             let config: Config = JSON.parse(await fs.readFileString(configPath));

     

       42
       42
       +
             // Assign the default values if they don't exist (newly added)

     

       43
       43
        
             config = { ...defaultConfig, ...config };

     

       44
       44
       -
             writeConfig(config);

     

       44
       44
       +
             await writeConfig(config);

     

       45
       45
        
       

     

       46
       46
        
             return config;

     

       47
       47
       -
           } else {

     

       48
       48
       -
             writeConfig(defaultConfig);

     

       49
       49
       -
             return defaultConfig;

     

       50
       50
       -
           }

     

       51
       51
       -
         }

     

       52
       52
       -
       

     

       53
       53
       -
         nodeTarget: {

     

       54
       54
       -
           const fs = requireImport("fs");

     

       55
       55
       -
           const configPath = getConfigPath();

     

       56
       56
       -
       

     

       57
       57
       -
           if (!fs.existsSync(configPath)) {

     

       58
       58
       -
             writeConfig(defaultConfig);

     

       47
       47
       +
           } catch (e) {

     

       48
       48
       +
             logger.error("Failed to read config, falling back to defaults", e);

     

       49
       49
       +
             // We don't want to write the default config here - if a user is manually

     

       50
       50
       +
             // editing their config and messes it up, we'll delete it all instead of

     

       51
       51
       +
             // letting them fix it

     

       59
       52
        
             return defaultConfig;

     

       60
       53
        
           }

     

       61
       61
       -
       

     

       62
       62
       -
           let config: Config = JSON.parse(fs.readFileSync(configPath, "utf8"));

     

       63
       63
       -
       

     

       64
       64
       -
           // Assign the default values if they don't exist (newly added)

     

       65
       65
       -
           config = { ...defaultConfig, ...config };

     

       66
       66
       -
           writeConfig(config);

     

       67
       67
       -
       

     

       68
       68
       -
           return config;

     

       69
       54
        
         }

     

       70
       70
       -
       

     

       71
       71
       -
         throw new Error("Called readConfig() in an impossible environment");

     

       72
       55
        
       }

+11 -76

packages/core/src/extension.ts

···

       2
       2
        
         ExtensionManifest,

     

       3
       3
        
         DetectedExtension,

     

       4
       4
        
         ExtensionLoadSource,

     

       5
       5
       -
         constants

     

       5
       5
       +
         constants,

     

       6
       6
       +
         MoonlightFS

     

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

     

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

     

       8
       8
       -
       import requireImport from "./util/import";

     

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

     

       10
       10
        
       import Logger from "./util/logger";

     

       11
       11
       +
       import getFS from "./fs";

     

       11
       12
        
       

     

       12
       13
        
       const logger = new Logger("core/extension");

     

       13
       14
        
       

     

       14
       14
       -
       // This is kinda duplicated from the browser FS type but idc

     

       15
       15
       -
       interface MoonlightFSWrapper {

     

       16
       16
       -
         readdir(path: string): Promise<string[]>;

     

       17
       17
       -
         exists(path: string): Promise<boolean>;

     

       18
       18
       -
         isFile(path: string): Promise<boolean>;

     

       19
       19
       -
         readFile(path: string): Promise<string>;

     

       20
       20
       -
         join(...parts: string[]): string;

     

       21
       21
       -
         dirname(path: string): string;

     

       22
       22
       -
       }

     

       23
       23
       -
       

     

       24
       24
       -
       function getFS(): MoonlightFSWrapper {

     

       25
       25
       -
         browser: {

     

       26
       26
       -
           const fs = window._moonlightBrowserFS!;

     

       27
       27
       -
           return {

     

       28
       28
       -
             async readdir(path) {

     

       29
       29
       -
               return await fs.readdir(path);

     

       30
       30
       -
             },

     

       31
       31
       -
             async exists(path) {

     

       32
       32
       -
               return await fs.exists(path);

     

       33
       33
       -
             },

     

       34
       34
       -
             async isFile(path) {

     

       35
       35
       -
               return await fs.isFile(path);

     

       36
       36
       -
             },

     

       37
       37
       -
             async readFile(path) {

     

       38
       38
       -
               const buf = await fs.readFile(path);

     

       39
       39
       -
               const text = new TextDecoder().decode(buf);

     

       40
       40
       -
               return text;

     

       41
       41
       -
             },

     

       42
       42
       -
             join(...parts) {

     

       43
       43
       -
               return fs.join(...parts);

     

       44
       44
       -
             },

     

       45
       45
       -
             dirname(path) {

     

       46
       46
       -
               return fs.dirname(path);

     

       47
       47
       -
             }

     

       48
       48
       -
           };

     

       49
       49
       -
         }

     

       50
       50
       -
       

     

       51
       51
       -
         const fs = requireImport("fs");

     

       52
       52
       -
         const path = requireImport("path");

     

       53
       53
       -
       

     

       54
       54
       -
         return {

     

       55
       55
       -
           async readdir(path) {

     

       56
       56
       -
             return fs.readdirSync(path);

     

       57
       57
       -
           },

     

       58
       58
       -
           async exists(path) {

     

       59
       59
       -
             return fs.existsSync(path);

     

       60
       60
       -
           },

     

       61
       61
       -
           async isFile(path) {

     

       62
       62
       -
             return fs.statSync(path).isFile();

     

       63
       63
       -
           },

     

       64
       64
       -
           async readFile(path) {

     

       65
       65
       -
             return fs.readFileSync(path, "utf8");

     

       66
       66
       -
           },

     

       67
       67
       -
           join(...parts) {

     

       68
       68
       -
             return path.join(...parts);

     

       69
       69
       -
           },

     

       70
       70
       -
           dirname(dir) {

     

       71
       71
       -
             return path.dirname(dir);

     

       72
       72
       -
           }

     

       73
       73
       -
         };

     

       74
       74
       -
       }

     

       75
       75
       -
       

     

       76
       76
       -
       async function findManifests(

     

       77
       77
       -
         fs: MoonlightFSWrapper,

     

       78
       78
       -
         dir: string

     

       79
       79
       -
       ): Promise<string[]> {

     

       15
       15
       +
       async function findManifests(fs: MoonlightFS, dir: string): Promise<string[]> {

     

       80
       16
        
         const ret = [];

     

       81
       17
        
       

     

       82
       18
        
         if (await fs.exists(dir)) {

     
···

       96
       32
        
       }

     

       97
       33
        
       

     

       98
       34
        
       async function loadDetectedExtensions(

     

       99
       99
       -
         fs: MoonlightFSWrapper,

     

       35
       35
       +
         fs: MoonlightFS,

     

       100
       36
        
         dir: string,

     

       101
       37
        
         type: ExtensionLoadSource

     

       102
       38
        
       ): Promise<DetectedExtension[]> {

     
···

       109
       45
        
             const dir = fs.dirname(manifestPath);

     

       110
       46
        
       

     

       111
       47
        
             const manifest: ExtensionManifest = JSON.parse(

     

       112
       112
       -
               await fs.readFile(manifestPath)

     

       48
       48
       +
               await fs.readFileString(manifestPath)

     

       113
       49
        
             );

     

       114
       50
        
             const level = manifest.apiLevel ?? 1;

     

       115
       51
        
             if (level !== constants.apiLevel) {

     
···

       126
       62
        
             }

     

       127
       63
        
       

     

       128
       64
        
             const web = (await fs.exists(webPath))

     

       129
       129
       -
               ? await fs.readFile(webPath)

     

       65
       65
       +
               ? await fs.readFileString(webPath)

     

       130
       66
        
               : undefined;

     

       131
       67
        
       

     

       132
       68
        
             let url: string | undefined = undefined;

     

       133
       69
        
             const urlPath = fs.join(dir, constants.repoUrlFile);

     

       134
       70
        
             if (type === ExtensionLoadSource.Normal && (await fs.exists(urlPath))) {

     

       135
       135
       -
               url = await fs.readFile(urlPath);

     

       71
       71
       +
               url = await fs.readFileString(urlPath);

     

       136
       72
        
             }

     

       137
       73
        
       

     

       138
       74
        
             const wpModules: Record<string, string> = {};

     
···

       142
       78
        
       

     

       143
       79
        
               for (const wpModuleFile of wpModulesFile) {

     

       144
       80
        
                 if (wpModuleFile.endsWith(".js")) {

     

       145
       145
       -
                   wpModules[wpModuleFile.replace(".js", "")] = await fs.readFile(

     

       146
       146
       -
                     fs.join(wpModulesPath, wpModuleFile)

     

       147
       147
       -
                   );

     

       81
       81
       +
                   wpModules[wpModuleFile.replace(".js", "")] =

     

       82
       82
       +
                     await fs.readFileString(fs.join(wpModulesPath, wpModuleFile));

     

       148
       83
        
                 }

     

       149
       84
        
               }

     

       150
       85
        
             }

     
···

       188
       123
        
         res.push(

     

       189
       124
        
           ...(await loadDetectedExtensions(

     

       190
       125
        
             fs,

     

       191
       191
       -
             getExtensionsPath(),

     

       126
       126
       +
             await getExtensionsPath(),

     

       192
       127
        
             ExtensionLoadSource.Normal

     

       193
       128
        
           ))

     

       194
       129
        
         );

+56

packages/core/src/fs.ts

···

       1
       1
       +
       import { MoonlightFS } from "types/src";

     

       2
       2
       +
       import requireImport from "./util/import";

     

       3
       3
       +
       

     

       4
       4
       +
       export default function getFS(): MoonlightFS {

     

       5
       5
       +
         browser: {

     

       6
       6
       +
           return window._moonlightBrowserFS!;

     

       7
       7
       +
         }

     

       8
       8
       +
       

     

       9
       9
       +
         nodeTarget: {

     

       10
       10
       +
           const fs = requireImport("fs");

     

       11
       11
       +
           const path = requireImport("path");

     

       12
       12
       +
       

     

       13
       13
       +
           return {

     

       14
       14
       +
             async readFile(path) {

     

       15
       15
       +
               const file = fs.readFileSync(path);

     

       16
       16
       +
               return new Uint8Array(file);

     

       17
       17
       +
             },

     

       18
       18
       +
             async readFileString(path) {

     

       19
       19
       +
               return fs.readFileSync(path, "utf8");

     

       20
       20
       +
             },

     

       21
       21
       +
             async writeFile(path, data) {

     

       22
       22
       +
               fs.writeFileSync(path, Buffer.from(data));

     

       23
       23
       +
             },

     

       24
       24
       +
             async writeFileString(path, data) {

     

       25
       25
       +
               fs.writeFileSync(path, data, "utf8");

     

       26
       26
       +
             },

     

       27
       27
       +
             async unlink(path) {

     

       28
       28
       +
               fs.unlinkSync(path);

     

       29
       29
       +
             },

     

       30
       30
       +
       

     

       31
       31
       +
             async readdir(path) {

     

       32
       32
       +
               return fs.readdirSync(path);

     

       33
       33
       +
             },

     

       34
       34
       +
             async mkdir(path) {

     

       35
       35
       +
               fs.mkdirSync(path, { recursive: true });

     

       36
       36
       +
             },

     

       37
       37
       +
             async rmdir(path) {

     

       38
       38
       +
               fs.rmSync(path, { recursive: true });

     

       39
       39
       +
             },

     

       40
       40
       +
       

     

       41
       41
       +
             async exists(path) {

     

       42
       42
       +
               return fs.existsSync(path);

     

       43
       43
       +
             },

     

       44
       44
       +
             async isFile(path) {

     

       45
       45
       +
               return fs.statSync(path).isFile();

     

       46
       46
       +
             },

     

       47
       47
       +
       

     

       48
       48
       +
             join(...parts) {

     

       49
       49
       +
               return path.join(...parts);

     

       50
       50
       +
             },

     

       51
       51
       +
             dirname(dir) {

     

       52
       52
       +
               return path.dirname(dir);

     

       53
       53
       +
             }

     

       54
       54
       +
           };

     

       55
       55
       +
         }

     

       56
       56
       +
       }

+30 -26

packages/core/src/util/data.ts

···

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

     

       2
       2
       -
       import requireImport from "./import";

     

       2
       2
       +
       import getFS from "../fs";

     

       3
       3
       +
       

     

       4
       4
       +
       export async function getMoonlightDir() {

     

       5
       5
       +
         browser: {

     

       6
       6
       +
           return "/";

     

       7
       7
       +
         }

     

       3
       8
        
       

     

       4
       4
       -
       export function getMoonlightDir(): string {

     

       5
       9
        
         const electron = require("electron");

     

       6
       6
       -
         const fs = requireImport("fs");

     

       7
       7
       -
         const path = requireImport("path");

     

       10
       10
       +
         const fs = getFS();

     

       8
       11
        
       

     

       9
       12
        
         let appData = "";

     

       10
       13
        
         injector: {

     
···

       15
       18
        
           appData = electron.ipcRenderer.sendSync(constants.ipcGetAppData);

     

       16
       19
        
         }

     

       17
       20
        
       

     

       18
       18
       -
         const dir = path.join(appData, "moonlight-mod");

     

       19
       19
       -
         if (!fs.existsSync(dir)) fs.mkdirSync(dir);

     

       21
       21
       +
         const dir = fs.join(appData, "moonlight-mod");

     

       22
       22
       +
         if (!(await fs.exists(dir))) await fs.mkdir(dir);

     

       20
       23
        
       

     

       21
       24
        
         return dir;

     

       22
       25
        
       }

     
···

       26
       29
        
         version: string;

     

       27
       30
        
       };

     

       28
       31
        
       

     

       29
       29
       -
       export function getConfigPath(): string {

     

       30
       30
       -
         const dir = getMoonlightDir();

     

       31
       31
       -
         const fs = requireImport("fs");

     

       32
       32
       -
         const path = requireImport("path");

     

       32
       32
       +
       export async function getConfigPath() {

     

       33
       33
       +
         browser: {

     

       34
       34
       +
           return "/config.json";

     

       35
       35
       +
         }

     

       36
       36
       +
       

     

       37
       37
       +
         const fs = getFS();

     

       38
       38
       +
         const dir = await getMoonlightDir();

     

       33
       39
        
       

     

       34
       40
        
         let configPath = "";

     

       35
       41
        
       

     

       36
       36
       -
         const buildInfoPath = path.join(process.resourcesPath, "build_info.json");

     

       37
       37
       -
         if (!fs.existsSync(buildInfoPath)) {

     

       38
       38
       -
           configPath = path.join(dir, "desktop.json");

     

       42
       42
       +
         const buildInfoPath = fs.join(process.resourcesPath, "build_info.json");

     

       43
       43
       +
         if (!(await fs.exists(buildInfoPath))) {

     

       44
       44
       +
           configPath = fs.join(dir, "desktop.json");

     

       39
       45
        
         } else {

     

       40
       46
        
           const buildInfo: BuildInfo = JSON.parse(

     

       41
       41
       -
             fs.readFileSync(buildInfoPath, "utf8")

     

       47
       47
       +
             await fs.readFileString(buildInfoPath)

     

       42
       48
        
           );

     

       43
       43
       -
           configPath = path.join(dir, buildInfo.releaseChannel + ".json");

     

       49
       49
       +
           configPath = fs.join(dir, buildInfo.releaseChannel + ".json");

     

       44
       50
        
         }

     

       45
       51
        
       

     

       46
       52
        
         return configPath;

     

       47
       53
        
       }

     

       48
       54
        
       

     

       49
       49
       -
       function getPathFromMoonlight(...names: string[]): string {

     

       50
       50
       -
         const dir = getMoonlightDir();

     

       51
       51
       -
         const fs = requireImport("fs");

     

       52
       52
       -
         const path = requireImport("path");

     

       55
       55
       +
       async function getPathFromMoonlight(...names: string[]) {

     

       56
       56
       +
         const dir = await getMoonlightDir();

     

       57
       57
       +
         const fs = getFS();

     

       53
       58
        
       

     

       54
       54
       -
         const target = path.join(dir, ...names);

     

       55
       55
       -
         if (!fs.existsSync(target)) fs.mkdirSync(target);

     

       59
       59
       +
         const target = fs.join(dir, ...names);

     

       60
       60
       +
         if (!(await fs.exists(target))) await fs.mkdir(target);

     

       56
       61
        
       

     

       57
       62
        
         return target;

     

       58
       63
        
       }

     

       59
       64
        
       

     

       60
       60
       -
       export function getExtensionsPath(): string {

     

       61
       61
       -
         return getPathFromMoonlight(constants.extensionsDir);

     

       65
       65
       +
       export async function getExtensionsPath() {

     

       66
       66
       +
         return await getPathFromMoonlight(constants.extensionsDir);

     

       62
       67
        
       }

     

       63
       68
        
       

     

       64
       69
        
       export function getCoreExtensionsPath(): string {

     

       65
       65
       -
         const path = requireImport("path");

     

       66
       66
       -
         const a = path.join(__dirname, constants.coreExtensionsDir);

     

       67
       67
       -
         return a;

     

       70
       70
       +
         const fs = getFS();

     

       71
       71
       +
         return fs.join(__dirname, constants.coreExtensionsDir);

     

       68
       72
        
       }

+8 -5

packages/node-preload/src/index.ts

···

       1
       1
        
       import { webFrame, ipcRenderer, contextBridge } from "electron";

     

       2
       2
       -
       import fs from "fs";

     

       3
       3
       -
       import path from "path";

     

       2
       2
       +
       import fs from "node:fs";

     

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

     

       4
       4
        
       

     

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

     

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

     
···

       14
       14
        
         loadExtensions,

     

       15
       15
        
         loadProcessedExtensions

     

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

     

       17
       17
       +
       import getFS from "@moonlight-mod/core/fs";

     

       17
       18
        
       

     

       18
       19
        
       async function injectGlobals() {

     

       19
       20
        
         const config = await readConfig();

     

       20
       21
        
         initLogger(config);

     

       21
       22
        
         const extensions = await getExtensions();

     

       22
       23
        
         const processedExtensions = await loadExtensions(extensions);

     

       24
       24
       +
         const moonlightDir = await getMoonlightDir();

     

       25
       25
       +
         const extensionsPath = await getExtensionsPath();

     

       23
       26
        
       

     

       24
       27
        
         function getConfig(ext: string) {

     

       25
       28
        
           const val = config.extensions[ext];

     
···

       32
       35
        
           extensions,

     

       33
       36
        
           processedExtensions,

     

       34
       37
        
           nativesCache: {},

     

       38
       38
       +
           fs: getFS(),

     

       35
       39
        
       

     

       36
       40
        
           version: MOONLIGHT_VERSION,

     

       37
       41
        
           branch: MOONLIGHT_BRANCH as MoonlightBranch,

     
···

       50
       54
        
           },

     

       51
       55
        
       

     

       52
       56
        
           getMoonlightDir() {

     

       53
       53
       -
             return getMoonlightDir();

     

       57
       57
       +
             return moonlightDir;

     

       54
       58
        
           },

     

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

     

       56
       56
       -
             const extPath = getExtensionsPath();

     

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

     

       60
       60
       +
             return path.join(extensionsPath, ext);

     

       58
       61
        
           },

     

       59
       62
        
           writeConfig

     

       60
       63
        
         };

+17

packages/types/src/fs.ts

···

       1
       1
       +
       export type MoonlightFS = {

     

       2
       2
       +
         readFile: (path: string) => Promise<Uint8Array>;

     

       3
       3
       +
         readFileString: (path: string) => Promise<string>;

     

       4
       4
       +
         writeFile: (path: string, data: Uint8Array) => Promise<void>;

     

       5
       5
       +
         writeFileString: (path: string, data: string) => Promise<void>;

     

       6
       6
       +
         unlink: (path: string) => Promise<void>;

     

       7
       7
       +
       

     

       8
       8
       +
         readdir: (path: string) => Promise<string[]>;

     

       9
       9
       +
         mkdir: (path: string) => Promise<void>;

     

       10
       10
       +
         rmdir: (path: string) => Promise<void>;

     

       11
       11
       +
       

     

       12
       12
       +
         exists: (path: string) => Promise<boolean>;

     

       13
       13
       +
         isFile: (path: string) => Promise<boolean>;

     

       14
       14
       +
       

     

       15
       15
       +
         join: (...parts: string[]) => string;

     

       16
       16
       +
         dirname: (path: string) => string;

     

       17
       17
       +
       };

+8 -19

packages/types/src/globals.ts

···

       9
       9
        
       import type EventEmitter from "events";

     

       10
       10
        
       import type LunAST from "@moonlight-mod/lunast";

     

       11
       11
        
       import type Moonmap from "@moonlight-mod/moonmap";

     

       12
       12
       -
       import { EventPayloads, EventType, MoonlightEventEmitter } from "./core/event";

     

       12
       12
       +
       import type {

     

       13
       13
       +
         EventPayloads,

     

       14
       14
       +
         EventType,

     

       15
       15
       +
         MoonlightEventEmitter

     

       16
       16
       +
       } from "./core/event";

     

       17
       17
       +
       import type { MoonlightFS } from "./fs";

     

       13
       18
        
       

     

       14
       19
        
       export type MoonlightHost = {

     

       15
       20
        
         asarPath: string;

     
···

       31
       36
        
         extensions: DetectedExtension[];

     

       32
       37
        
         processedExtensions: ProcessedExtensions;

     

       33
       38
        
         nativesCache: Record<string, any>;

     

       39
       39
       +
         fs: MoonlightFS;

     

       34
       40
        
       

     

       35
       41
        
         version: string;

     

       36
       42
        
         branch: MoonlightBranch;

     
···

       42
       48
        
       

     

       43
       49
        
         getMoonlightDir: () => string;

     

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

     

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

     

       46
       46
       -
       };

     

       47
       47
       -
       

     

       48
       48
       -
       export type MoonlightBrowserFS = {

     

       49
       49
       -
         readFile: (path: string) => Promise<Uint8Array>;

     

       50
       50
       -
         writeFile: (path: string, data: Uint8Array) => Promise<void>;

     

       51
       51
       -
         unlink: (path: string) => Promise<void>;

     

       52
       52
       -
       

     

       53
       53
       -
         readdir: (path: string) => Promise<string[]>;

     

       54
       54
       -
         mkdir: (path: string) => Promise<void>;

     

       55
       55
       -
         rmdir: (path: string) => Promise<void>;

     

       56
       56
       -
       

     

       57
       57
       -
         exists: (path: string) => Promise<boolean>;

     

       58
       58
       -
         isFile: (path: string) => Promise<boolean>;

     

       59
       59
       -
       

     

       60
       60
       -
         join: (...parts: string[]) => string;

     

       61
       61
       -
         dirname: (path: string) => string;

     

       62
       62
       -
         parts: (path: string) => string[];

     

       51
       51
       +
         writeConfig: (config: Config) => Promise<void>;

     

       63
       52
        
       };

     

       64
       53
        
       

     

       65
       54
        
       export type MoonlightWeb = {

+3 -2

packages/types/src/index.ts

···

       4
       4
        
       /// <reference types="./mappings" />

     

       5
       5
        
       /* eslint-disable no-var */

     

       6
       6
        
       

     

       7
       7
       +
       import { MoonlightFS } from "./fs";

     

       7
       8
        
       import {

     

       8
       8
       -
         MoonlightBrowserFS,

     

       9
       9
        
         MoonlightEnv,

     

       10
       10
        
         MoonlightHost,

     

       11
       11
        
         MoonlightNode,

     
···

       19
       19
        
       export * from "./globals";

     

       20
       20
        
       export * from "./logger";

     

       21
       21
        
       export * as constants from "./constants";

     

       22
       22
       +
       export * from "./fs";

     

       22
       23
        
       

     

       23
       24
        
       export type { AST } from "@moonlight-mod/lunast";

     

       24
       25
        
       export { ModuleExport, ModuleExportType } from "@moonlight-mod/moonmap";

     
···

       39
       40
        
       

     

       40
       41
        
         var _moonlightBrowserInit: () => Promise<void>;

     

       41
       42
        
         var _moonlightBrowserLoad: () => Promise<void>;

     

       42
       42
       -
         var _moonlightBrowserFS: MoonlightBrowserFS | undefined;

     

       43
       43
       +
         var _moonlightBrowserFS: MoonlightFS;

     

       43
       44
        
       }