391 lines
16 KiB
JavaScript
391 lines
16 KiB
JavaScript
import Utilities from "./utilities";
|
|
import Logger from "common/logger";
|
|
import Settings from "./settingsmanager";
|
|
import Events from "./emitter";
|
|
import DataStore from "./datastore";
|
|
import AddonError from "../structs/addonerror";
|
|
import MetaError from "../structs/metaerror";
|
|
import Toasts from "../ui/toasts";
|
|
import DiscordModules from "./discordmodules";
|
|
import Strings from "./strings";
|
|
import AddonEditor from "../ui/misc/addoneditor";
|
|
import FloatingWindows from "../ui/floatingwindows";
|
|
|
|
const React = DiscordModules.React;
|
|
|
|
const path = require("path");
|
|
const fs = require("fs");
|
|
const Module = require("module").Module;
|
|
|
|
const splitRegex = /[^\S\r\n]*?\r?(?:\r\n|\n)[^\S\r\n]*?\*[^\S\r\n]?/;
|
|
const escapedAtRegex = /^\\@/;
|
|
|
|
const stripBOM = function(fileContent) {
|
|
if (fileContent.charCodeAt(0) === 0xFEFF) {
|
|
fileContent = fileContent.slice(1);
|
|
}
|
|
return fileContent;
|
|
};
|
|
|
|
export default class AddonManager {
|
|
|
|
get name() {return "";}
|
|
get moduleExtension() {return "";}
|
|
get extension() {return "";}
|
|
get duplicatePattern() {return /./;}
|
|
get addonFolder() {return "";}
|
|
get language() {return "";}
|
|
get prefix() {return "addon";}
|
|
get collection() {return "settings";}
|
|
get category() {return "addons";}
|
|
get id() {return "autoReload";}
|
|
emit(event, ...args) {return Events.emit(`${this.prefix}-${event}`, ...args);}
|
|
|
|
constructor() {
|
|
this.timeCache = {};
|
|
this.addonList = [];
|
|
this.state = {};
|
|
this.windows = new Set();
|
|
}
|
|
|
|
async initialize() {
|
|
this.originalRequire = Module._extensions[this.moduleExtension];
|
|
Module._extensions[this.moduleExtension] = this.getAddonRequire();
|
|
Settings.on(this.collection, this.category, this.id, (enabled) => {
|
|
if (enabled) this.watchAddons();
|
|
else this.unwatchAddons();
|
|
});
|
|
return await this.loadAllAddons();
|
|
}
|
|
|
|
// Subclasses should overload this and modify the addon object as needed to fully load it
|
|
initializeAddon() {return;}
|
|
|
|
// Subclasses should overload this and modify the fileContent as needed to require() the file
|
|
getFileModification(module, fileContent) {return fileContent;}
|
|
|
|
startAddon() {return;}
|
|
stopAddon() {return;}
|
|
|
|
loadState() {
|
|
const saved = DataStore.getData(`${this.prefix}s`);
|
|
if (!saved) return;
|
|
Object.assign(this.state, saved);
|
|
}
|
|
|
|
saveState() {
|
|
DataStore.setData(`${this.prefix}s`, this.state);
|
|
}
|
|
|
|
watchAddons() {
|
|
if (this.watcher) return Logger.err(this.name, `Already watching ${this.prefix} addons.`);
|
|
Logger.log(this.name, `Starting to watch ${this.prefix} addons.`);
|
|
this.watcher = fs.watch(this.addonFolder, {persistent: false}, async (eventType, filename) => {
|
|
if (!eventType || !filename) return;
|
|
|
|
const absolutePath = path.resolve(this.addonFolder, filename);
|
|
if (!filename.endsWith(this.extension)) {
|
|
// Lets check to see if this filename has the duplicated file pattern `something(1).ext`
|
|
const match = filename.match(this.duplicatePattern);
|
|
if (!match) return;
|
|
const ext = match[0];
|
|
const truncated = filename.replace(ext, "");
|
|
const newFilename = truncated + this.extension;
|
|
|
|
// If this file already exists, give a warning and move on.
|
|
if (fs.existsSync(newFilename)) {
|
|
Logger.warn("AddonManager", `Duplicate files found: ${filename} and ${newFilename}`);
|
|
return;
|
|
}
|
|
|
|
// Rename the file and let it go on
|
|
fs.renameSync(absolutePath, path.resolve(this.addonFolder, newFilename));
|
|
}
|
|
|
|
await new Promise(r => setTimeout(r, 100));
|
|
try {
|
|
const stats = fs.statSync(absolutePath);
|
|
if (!stats.isFile()) return;
|
|
if (!stats || !stats.mtime || !stats.mtime.getTime()) return;
|
|
if (typeof(stats.mtime.getTime()) !== "number") return;
|
|
if (this.timeCache[filename] == stats.mtime.getTime()) return;
|
|
this.timeCache[filename] = stats.mtime.getTime();
|
|
if (eventType == "rename") this.loadAddon(filename, true);
|
|
if (eventType == "change") this.reloadAddon(filename, true);
|
|
}
|
|
catch (err) {
|
|
if (err.code !== "ENOENT") return;
|
|
delete this.timeCache[filename];
|
|
this.unloadAddon(filename, true);
|
|
}
|
|
});
|
|
}
|
|
|
|
unwatchAddons() {
|
|
if (!this.watcher) return Logger.error(this.name, `Was not watching ${this.prefix} addons.`);
|
|
this.watcher.close();
|
|
delete this.watcher;
|
|
Logger.log(this.name, `No longer watching ${this.prefix} addons.`);
|
|
}
|
|
|
|
extractMeta(fileContent) {
|
|
const firstLine = fileContent.split("\n")[0];
|
|
const hasOldMeta = firstLine.includes("//META");
|
|
if (hasOldMeta) return this.parseOldMeta(fileContent);
|
|
const hasNewMeta = firstLine.includes("/**");
|
|
if (hasNewMeta) return this.parseNewMeta(fileContent);
|
|
throw new MetaError(Strings.Addons.metaNotFound);
|
|
}
|
|
|
|
parseOldMeta(fileContent) {
|
|
const meta = fileContent.split("\n")[0];
|
|
const metaData = meta.substring(meta.lastIndexOf("//META") + 6, meta.lastIndexOf("*//"));
|
|
const parsed = Utilities.testJSON(metaData);
|
|
if (!parsed) throw new MetaError(Strings.Addons.metaError);
|
|
if (!parsed.name) throw new MetaError(Strings.Addons.missingNameData);
|
|
parsed.format = "json";
|
|
return parsed;
|
|
}
|
|
|
|
parseNewMeta(fileContent) {
|
|
const block = fileContent.split("/**", 2)[1].split("*/", 1)[0];
|
|
const out = {};
|
|
let field = "";
|
|
let accum = "";
|
|
for (const line of block.split(splitRegex)) {
|
|
if (line.length === 0) continue;
|
|
if (line.charAt(0) === "@" && line.charAt(1) !== " ") {
|
|
out[field] = accum;
|
|
const l = line.indexOf(" ");
|
|
field = line.substr(1, l - 1);
|
|
accum = line.substr(l + 1);
|
|
}
|
|
else {
|
|
accum += " " + line.replace("\\n", "\n").replace(escapedAtRegex, "@");
|
|
}
|
|
}
|
|
out[field] = accum.trim();
|
|
delete out[""];
|
|
out.format = "jsdoc";
|
|
return out;
|
|
}
|
|
|
|
getAddonRequire() {
|
|
const self = this;
|
|
// const baseFolder = this.addonFolder;
|
|
const originalRequire = this.originalRequire;
|
|
return function(module, filename) {
|
|
const possiblePath = path.resolve(self.addonFolder, path.basename(filename));
|
|
if (!fs.existsSync(possiblePath) || filename !== fs.realpathSync(possiblePath)) return Reflect.apply(originalRequire, this, arguments);
|
|
let fileContent = fs.readFileSync(filename, "utf8");
|
|
fileContent = stripBOM(fileContent);
|
|
const stats = fs.statSync(filename);
|
|
const meta = self.extractMeta(fileContent);
|
|
if (!meta.author) meta.author = Strings.Addons.unknownAuthor;
|
|
if (!meta.version) meta.version = "???";
|
|
if (!meta.description) meta.description = Strings.Addons.noDescription;
|
|
meta.id = meta.name;
|
|
meta.filename = path.basename(filename);
|
|
meta.added = stats.atimeMs;
|
|
meta.modified = stats.mtimeMs;
|
|
meta.size = stats.size;
|
|
fileContent = self.getFileModification(module, fileContent, meta);
|
|
module._compile(fileContent, filename);
|
|
};
|
|
}
|
|
|
|
// Subclasses should use the return (if not AddonError) and push to this.addonList
|
|
async loadAddon(filename, shouldToast = false) {
|
|
if (typeof(filename) === "undefined") return;
|
|
try {
|
|
const addon = __non_webpack_require__(path.resolve(this.addonFolder, filename));
|
|
await Promise.resolve(addon);
|
|
}
|
|
catch (error) {
|
|
return new AddonError(filename, filename, Strings.Addons.compileError, {message: error.message, stack: error.stack});
|
|
}
|
|
|
|
const addon = __non_webpack_require__(path.resolve(this.addonFolder, filename));
|
|
// console.log(addon);
|
|
// await Promise.resolve(addon);
|
|
// addon = __non_webpack_require__(path.resolve(this.addonFolder, filename));
|
|
// console.log(addon);
|
|
if (this.addonList.find(c => c.id == addon.id)) return new AddonError(addon.name, filename, Strings.Addons.alreadyExists.format({type: this.prefix, name: addon.name}));
|
|
|
|
const error = this.initializeAddon(addon);
|
|
if (error) return error;
|
|
|
|
this.addonList.push(addon);
|
|
if (shouldToast) Toasts.success(`${addon.name} v${addon.version} was loaded.`);
|
|
this.emit("loaded", addon.id);
|
|
|
|
if (!this.state[addon.id]) return this.state[addon.id] = false;
|
|
return this.startAddon(addon);
|
|
}
|
|
|
|
unloadAddon(idOrFileOrAddon, shouldToast = true, isReload = false) {
|
|
const addon = typeof(idOrFileOrAddon) == "string" ? this.addonList.find(c => c.id == idOrFileOrAddon || c.filename == idOrFileOrAddon) : idOrFileOrAddon;
|
|
if (!addon) return false;
|
|
if (this.state[addon.id]) isReload ? this.stopAddon(addon) : this.disableAddon(addon);
|
|
delete __non_webpack_require__.cache[__non_webpack_require__.resolve(path.resolve(this.addonFolder, addon.filename))];
|
|
this.addonList.splice(this.addonList.indexOf(addon), 1);
|
|
this.emit("unloaded", addon.id);
|
|
if (shouldToast) Toasts.success(`${addon.name} was unloaded.`);
|
|
return true;
|
|
}
|
|
|
|
async reloadAddon(idOrFileOrAddon, shouldToast = true) {
|
|
const addon = typeof(idOrFileOrAddon) == "string" ? this.addonList.find(c => c.id == idOrFileOrAddon || c.filename == idOrFileOrAddon) : idOrFileOrAddon;
|
|
const didUnload = this.unloadAddon(addon, shouldToast, true);
|
|
if (addon && !didUnload) return didUnload;
|
|
return await this.loadAddon(addon ? addon.filename : idOrFileOrAddon, shouldToast);
|
|
}
|
|
|
|
isLoaded(idOrFile) {
|
|
const addon = this.addonList.find(c => c.id == idOrFile || c.filename == idOrFile);
|
|
if (!addon) return false;
|
|
return true;
|
|
}
|
|
|
|
isEnabled(idOrFile) {
|
|
const addon = this.addonList.find(c => c.id == idOrFile || c.filename == idOrFile);
|
|
if (!addon) return false;
|
|
return this.state[addon.id];
|
|
}
|
|
|
|
getAddon(idOrFile) {
|
|
return this.addonList.find(c => c.id == idOrFile || c.filename == idOrFile);
|
|
}
|
|
|
|
enableAddon(idOrAddon) {
|
|
const addon = typeof(idOrAddon) == "string" ? this.addonList.find(p => p.id == idOrAddon) : idOrAddon;
|
|
if (!addon) return;
|
|
if (this.state[addon.id]) return;
|
|
this.state[addon.id] = true;
|
|
this.startAddon(addon);
|
|
this.saveState();
|
|
}
|
|
|
|
disableAddon(idOrAddon) {
|
|
const addon = typeof(idOrAddon) == "string" ? this.addonList.find(p => p.id == idOrAddon) : idOrAddon;
|
|
if (!addon) return;
|
|
if (!this.state[addon.id]) return;
|
|
this.state[addon.id] = false;
|
|
this.stopAddon(addon);
|
|
this.saveState();
|
|
}
|
|
|
|
toggleAddon(id) {
|
|
if (this.state[id]) this.disableAddon(id);
|
|
else this.enableAddon(id);
|
|
}
|
|
|
|
loadNewAddons() {
|
|
const files = fs.readdirSync(this.addonFolder);
|
|
const removed = this.addonList.filter(t => !files.includes(t.filename)).map(c => c.id);
|
|
const added = files.filter(f => !this.addonList.find(t => t.filename == f) && f.endsWith(this.extension) && fs.statSync(path.resolve(this.addonFolder, f)).isFile());
|
|
return {added, removed};
|
|
}
|
|
|
|
updateList() {
|
|
const results = this.loadNewAddons();
|
|
for (const filename of results.added) this.loadAddon(filename);
|
|
for (const name of results.removed) this.unloadAddon(name);
|
|
}
|
|
|
|
async loadAllAddons() {
|
|
this.loadState();
|
|
const errors = [];
|
|
const files = fs.readdirSync(this.addonFolder);
|
|
|
|
for (const filename of files) {
|
|
const absolutePath = path.resolve(this.addonFolder, filename);
|
|
const stats = fs.statSync(absolutePath);
|
|
if (!stats || !stats.isFile()) continue;
|
|
this.timeCache[filename] = stats.mtime.getTime();
|
|
|
|
if (!filename.endsWith(this.extension)) {
|
|
// Lets check to see if this filename has the duplicated file pattern `something(1).ext`
|
|
const match = filename.match(this.duplicatePattern);
|
|
if (!match) continue;
|
|
const ext = match[0];
|
|
const truncated = filename.replace(ext, "");
|
|
const newFilename = truncated + this.extension;
|
|
|
|
// If this file already exists, give a warning and move on.
|
|
if (fs.existsSync(newFilename)) {
|
|
Logger.warn("AddonManager", `Duplicate files found: ${filename} and ${newFilename}`);
|
|
continue;
|
|
}
|
|
|
|
// Rename the file and let it go on
|
|
fs.renameSync(absolutePath, path.resolve(this.addonFolder, newFilename));
|
|
}
|
|
const addon = await this.loadAddon(filename, false);
|
|
if (addon instanceof AddonError) errors.push(addon);
|
|
}
|
|
|
|
this.saveState();
|
|
if (Settings.get(this.collection, this.category, this.id)) this.watchAddons();
|
|
return errors;
|
|
}
|
|
|
|
deleteAddon(idOrFileOrAddon) {
|
|
const addon = typeof(idOrFileOrAddon) == "string" ? this.addonList.find(c => c.id == idOrFileOrAddon || c.filename == idOrFileOrAddon) : idOrFileOrAddon;
|
|
return fs.unlinkSync(path.resolve(this.addonFolder, addon.filename));
|
|
}
|
|
|
|
saveAddon(idOrFileOrAddon, content) {
|
|
const addon = typeof(idOrFileOrAddon) == "string" ? this.addonList.find(c => c.id == idOrFileOrAddon || c.filename == idOrFileOrAddon) : idOrFileOrAddon;
|
|
return fs.writeFileSync(path.resolve(this.addonFolder, addon.filename), content);
|
|
}
|
|
|
|
editAddon(idOrFileOrAddon, system) {
|
|
const addon = typeof(idOrFileOrAddon) == "string" ? this.addonList.find(c => c.id == idOrFileOrAddon || c.filename == idOrFileOrAddon) : idOrFileOrAddon;
|
|
const fullPath = path.resolve(this.addonFolder, addon.filename);
|
|
if (typeof(system) == "undefined") system = Settings.get("settings", "addons", "editAction") == "system";
|
|
if (system) return require("electron").shell.openItem(`${fullPath}`);
|
|
return this.openDetached(addon);
|
|
}
|
|
|
|
openDetached(addon) {
|
|
const fullPath = path.resolve(this.addonFolder, addon.filename);
|
|
const content = fs.readFileSync(fullPath).toString();
|
|
|
|
if (this.windows.has(fullPath)) return;
|
|
this.windows.add(fullPath);
|
|
|
|
const editorRef = React.createRef();
|
|
const editor = React.createElement(AddonEditor, {
|
|
id: "bd-floating-editor-" + addon.id,
|
|
ref: editorRef,
|
|
content: content,
|
|
save: this.saveAddon.bind(this, addon),
|
|
openNative: this.editAddon.bind(this, addon, true),
|
|
language: this.language
|
|
});
|
|
|
|
FloatingWindows.open({
|
|
onClose: () => {
|
|
this.windows.delete(fullPath);
|
|
},
|
|
onResize: () => {
|
|
if (!editorRef || !editorRef.current || !editorRef.current.resize) return;
|
|
editorRef.current.resize();
|
|
},
|
|
title: addon.name,
|
|
id: "bd-floating-window-" + addon.id,
|
|
className: "floating-addon-window",
|
|
height: 470,
|
|
width: 410,
|
|
center: true,
|
|
resizable: true,
|
|
children: editor,
|
|
confirmClose: () => {
|
|
if (!editorRef || !editorRef.current) return false;
|
|
return editorRef.current.hasUnsavedChanges;
|
|
},
|
|
confirmationText: Strings.Addons.confirmationText.format({name: addon.name})
|
|
});
|
|
}
|
|
} |