Merge pull request #318 from JsSucks/2.0.0-beta.6

beta6

.editorconfig

@@ -2,6 +2,7 @@ root = true
 
 [*]
 end_of_line = lf
+insert_final_newline = true
 trim_trailing_whitespace = true
 
 indent_style = space

.eslintrc

@@ -0,0 +1,42 @@
+{
+    "parserOptions": {
+        "ecmaVersion": 8,
+        "sourceType": "module"
+    },
+    "env": {
+        "browser": true,
+        "node": true
+    },
+    "plugins": [
+        "vue"
+    ],
+    "extends": [
+        "eslint:recommended",
+        "plugin:vue/recommended"
+    ],
+    "rules": {
+        "no-unused-vars": "off",
+        "no-console": "off",
+        "no-empty": "off",
+        "quotes": [
+            "error",
+            "single",
+            { "allowTemplateLiterals": true }
+        ],
+        "prefer-template": "warn",
+        "no-return-await": "error",
+        "indent": [ "warn", 4 ],
+        "no-lonely-if": "error",
+        "no-multiple-empty-lines": [
+            "warn",
+            { "max": 1 }
+        ],
+        "no-tabs": "warn",
+        "no-trailing-spaces": "warn",
+        "no-unneeded-ternary": "warn",
+        "no-useless-constructor": "warn",
+        "no-var": "error",
+        "prefer-const": "error",
+        "no-else-return": "error"
+    }
+}

.eslintrc.yml

@@ -1,21 +0,0 @@
----
-
-parserOptions:
-  ecmaVersion: 8
-  sourceType: module
-
-env:
-  browser: true
-  node: true
-
-plugins:
-  - vue
-
-extends:
-  - eslint:recommended
-  - plugin:vue/recommended
-
-rules:
-  no-unused-vars: 'off'
-  no-console: 'off'
-  no-empty: 'off'

.gitattributes

@@ -1 +1 @@
-*.sh text=auto
+*.sh text=auto

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,33 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[Bug]"
+labels: bug
+assignees: ''
+
+---
+
+- [ ] Used appropriate template for the issue type
+- [ ] Searched both open and closed issues for duplicates of this issue
+- [ ] Title adequately and _concisely_ reflects the feature or the bug
+
+**Describe the bug**
+<!-- A clear and concise description of what the bug is. -->
+
+**To Reproduce**
+<!-- Steps to reproduce the behavior -->
+
+**Expected behavior**
+<!-- A clear and concise description of what you expected to happen. -->
+
+**Screenshots**
+<!-- If applicable, add screenshots to help explain your problem. -->
+
+**System information**
+<!-- os, discord branch etc -->
+
+**Additional context**
+<!-- Add any other context about the problem here. -->
+
+**Are you willing and able to fix this?**
+<!-- "Yes" or, if "no", what can current contributors do to help you create a PR? -->

.github/ISSUE_TEMPLATE/custom.md

@@ -0,0 +1,12 @@
+---
+name: Custom issue template
+about: Describe this issue template's purpose here.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+- [ ] Used appropriate template for the issue type
+- [ ] Searched both open and closed issues for duplicates of this issue
+- [ ] Title adequately and _concisely_ reflects the feature or the bug

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,27 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[Feature]"
+labels: feature
+assignees: ''
+
+---
+
+- [ ] Used appropriate template for the issue type
+- [ ] Searched both open and closed issues for duplicates of this issue
+- [ ] Title adequately and _concisely_ reflects the feature or the bug
+
+**Is your feature request related to a problem? Please describe.**
+<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
+
+**Describe the solution you'd like**
+<!-- A clear and concise description of what you want to happen. -->
+
+**Describe alternatives you've considered**
+<!-- A clear and concise description of any alternative solutions or features you've considered. -->
+
+**Additional context**
+<!-- Add any other context or screenshots about the feature request here. -->
+
+**Are you willing and able to implement this?**
+<!-- "Yes" or, if "no", what can current contributors do to help you create a PR? -->

.gitignore

@@ -1,24 +1,16 @@
-.idea/*
-*.name
-devjs/.idea/devjs.iml
-*.bak
-*.bak.*
-*.xpi
-Firefox/data/js/jquery-2.1.4.min.js
-*.dev.*
-/nbproject/private/
+# Generated files
 node_modules
-.sass-cache
-/*.jiiks
-Installers/dotNet/bin/
-Installers/dotNet/packages/
-Installers/dotNet/dlls/
-v2/dist/vendor/
-v2/lib/static.js
-**/*.suo
-Installers/**/*/bin
-Installers/**/*/obj
-Installers/**/*/packages
-.vs
-dist/
-user.config.json
+dist
+etc
+release
+
+tests/tmp
+tests/log.txt
+
+# User data
+tests/data
+user.config.json
+/.vs
+/npm-debug.log
+/tests/ext/extensions
+/tests/userdata

.sasslintrc

@@ -0,0 +1,29 @@
+{
+    "rules": {
+        "no-transition-all": [ 0 ],
+        "nesting-depth": [
+            1,
+            { "max-depth": 5 }
+        ],
+        "no-vendor-prefixes": [ 0 ],
+        "property-sort-order": [ 0 ],
+        "indentation": [
+            1,
+            { "size": 4 }
+        ],
+        "no-color-literals": [ 0 ],
+        "class-name-format": [
+            1,
+            {
+                "convention": "^bd-[a-z]"
+            }
+        ],
+        "variable-name-format": [
+            2,
+            {
+                "convention": "camelcase"
+            }
+        ],
+        "url-quotes": [ 0 ]
+    }
+}

.travis.yml

@@ -1,6 +1,13 @@
 language: node_js
+
 node_js:
 - stable
+
 branches:
   only:
-  - master
+  - master
+
+addons:
+  apt:
+    packages:
+    - libsecret-1-dev

LICENSE

@@ -6,4 +6,4 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.MD

@@ -1,3 +0,0 @@
-# BetterDiscordApp [![Travis][build-badge]][build]
-[build-badge]: https://img.shields.io/travis/JsSucks/BetterDiscordApp/master.svg
-[build]: https://travis-ci.org/JsSucks/BetterDiscordApp

README.md

@@ -0,0 +1,12 @@
+# BetterDiscordApp [![Travis][build-badge]][build] [![Snyk][snyk-badge]][snyk-url] [![deps][deps-badge]][deps-url] [![devdeps][devdeps-badge]][devdeps-url]
+
+[build-badge]: https://img.shields.io/travis/JsSucks/BetterDiscordApp/master.svg
+[build]: https://travis-ci.org/JsSucks/BetterDiscordApp
+
+[snyk-badge]: https://snyk.io/test/github/JsSucks/BetterDiscordApp/badge.svg
+[snyk-url]: https://snyk.io/test/github/JsSucks/BetterDiscordApp
+
+[deps-badge]: https://david-dm.org/JsSucks/BetterDiscordApp.svg
+[deps-url]: https://david-dm.org/JsSucks/BetterDiscordApp
+[devdeps-badge]: https://david-dm.org/JsSucks/BetterDiscordApp/dev-status.svg
+[devdeps-url]: https://david-dm.org/JsSucks/BetterDiscordApp?type=dev

babel.config.js

@@ -0,0 +1,17 @@
+module.exports = function(api) {
+
+    api.cache(true);
+
+    const presets = [['@babel/env', {
+        targets: {
+            'node': '8.6.0'
+        }
+    }]];
+
+    const plugins = [];
+
+    return {
+        presets,
+        plugins
+    }
+}

client/babel.config.js

@@ -0,0 +1,18 @@
+module.exports = function(api) {
+
+    api.cache(true);
+
+    const presets = [['@babel/env', {
+        targets: {
+            'node': '8.6.0',
+            'chrome': '60'
+        }
+    }], '@babel/react'];
+
+    const plugins = [];
+
+    return {
+        presets,
+        plugins
+    }
+}

client/jsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+      "target": "es2017",
+      "allowSyntheticDefaultImports": false,
+      "baseUrl": "./",
+      "paths": {
+        "modules": ["./src/modules/modules.js"],
+        "structs": ["./src/structs/structs.js"],
+        "common": ["../common/modules/common.js"],
+        "ui": ["./src/ui/ui.js"],
+        "builtin": ["./src/builtin/builtin.js"],
+        "vue$": ["../node_modules/vue/dist/vue.esm.js"]
+      }
+    },
+    "exclude": ["node_modules", "dist"]
+}

client/package.json

@@ -2,24 +2,22 @@
   "name": "bdclient",
   "description": "BetterDiscord client package",
   "author": "Jiiks",
-  "version": "0.4.0",
+  "version": "2.0.0-beta.6",
   "homepage": "https://betterdiscord.net",
   "license": "MIT",
-  "main": "index.js",
+  "main": "dist/betterdiscord.client.js",
   "contributors": [
     "Jiiks",
     "Pohky"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/Jiiks/BetterDiscordApp.git"
+    "url": "https://github.com/JsSucks/BetterDiscordApp.git"
   },
   "private": false,
-  "devDependencies": {
-    
-  },
   "scripts": {
     "build": "webpack --progress --colors",
-    "watch": "webpack --progress --colors --watch"
+    "watch": "webpack --progress --colors --watch",
+    "release": "webpack --progress --colors --config=webpack.production.config.js"
   }
 }

client/src/builtin/24Hour.js

@@ -0,0 +1,40 @@
+/**
+ * BetterDiscord 24 Hour Timestamps Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BuiltinModule from './BuiltinModule';
+import { Reflection } from 'modules';
+
+const twelveHour = new RegExp(`([0-9]{1,2}):([0-9]{1,2})\\s(AM|PM)`);
+
+export default new class TwentyFourHour extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'TwentyFourHour' }
+
+    get settingPath() { return ['ui', 'default', '24-hour'] }
+
+    /* Patches */
+    applyPatches() {
+        if (this.patches.length) return;
+        const { TimeFormatter } = Reflection.modules;
+        this.patch(TimeFormatter, 'calendarFormat', this.convertTimeStamps);
+    }
+
+    /**
+     * Convert 12 hours timestamps to 24 hour timestamps
+     */
+    convertTimeStamps(that, args, returnValue) {
+        const matched = returnValue.match(twelveHour);
+        if (!matched || matched.length !== 4) return;
+        if (matched[3] === 'AM') return returnValue.replace(matched[0], `${matched[1] === '12' ? '00' : matched[1].padStart(2, '0')}:${matched[2]}`)
+        return returnValue.replace(matched[0], `${parseInt(matched[1]) + 12}:${matched[2]}`)
+    }
+
+}

client/src/builtin/BlockedMessages.js

@@ -0,0 +1,56 @@
+/**
+ * BetterDiscord Blocked Messages Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BuiltinModule from './BuiltinModule';
+import { Reflection } from 'modules';
+
+export default new class BlockedMessages extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'BlockedMessages' }
+
+    get settingPath() { return ['ui', 'default', 'blocked-messages'] }
+
+    async enabled(e) {
+        const MessageListComponents = Reflection.module.byProps('BlockedMessageGroup');
+        MessageListComponents.OriginalBlockedMessageGroup = MessageListComponents.BlockedMessageGroup;
+        MessageListComponents.BlockedMessageGroup = () => null;
+        this.cancelBlockedMessages = () => {
+            MessageListComponents.BlockedMessageGroup = MessageListComponents.OriginalBlockedMessageGroup;
+            delete MessageListComponents.OriginalBlockedMessageGroup;
+        }
+    }
+
+    disabled(e) {
+        if (this.cancelBlockedMessages) this.cancelBlockedMessages();
+    }
+
+    /* Methods */
+    static isBlocked(id) {
+        const { RelationshipStore } = Reflection.modules;
+        return RelationshipStore.isBlocked(id);
+    }
+
+    /* Patches */
+    applyPatches() {
+        if (this.patches.length) return;
+        const { MessageActions } = Reflection.modules;
+        this.patch(MessageActions, 'receiveMessage', this.processMessage, 'instead');
+    }
+
+    /**
+     * Ignore blocked messages completely
+     */
+    processMessage(that, args, originalFunction) {
+        if (args[1] && args[1].author && args[1].author.id && BlockedMessages.isBlocked(args[1].author.id)) return;
+        return originalFunction(...args);
+    }
+
+}

client/src/builtin/BuiltinModule.js

@@ -0,0 +1,106 @@
+/**
+ * BetterDiscord Builtin Module Base
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Settings } from 'modules';
+import { Patcher, MonkeyPatch as Patch, Cache } from 'modules';
+import { ClientLogger as Logger } from 'common';
+
+export default class BuiltinModule {
+
+    constructor() {
+        this._settingUpdated = this._settingUpdated.bind(this);
+        if (this.enabled) this.enabled = this.enabled.bind(this);
+        if (this.disabled) this.disabled = this.disabled.bind(this);
+        if (this.applyPatches) this.applyPatches = this.applyPatches.bind(this);
+        this.patch = this.patch.bind(this);
+    }
+
+    async init() {
+        this.setting.on('setting-updated', this._settingUpdated);
+        if (this.setting.value) {
+            if (this.enabled) await this.enabled();
+            if (this.applyPatches) this.applyPatches();
+        }
+    }
+
+    get setting() {
+        return Settings.getSetting(...this.settingPath);
+    }
+
+    get patches() {
+        return Patcher.getPatchesByCaller(`BD:${this.moduleName}`);
+    }
+
+    async _settingUpdated(e) {
+        if (e.value) {
+            if (this.enabled) await this.enabled(e);
+            if (this.applyPatches) await this.applyPatches();
+            if (this.rerenderPatchedComponents) this.rerenderPatchedComponents();
+        } else {
+            if (this.disabled) await this.disabled(e);
+            this.unpatch();
+            if (this.rerenderPatchedComponents) this.rerenderPatchedComponents();
+        }
+    }
+
+    get cache() {
+        return {
+            push: data => Cache.push(this.moduleName, data),
+            find: filter => Cache.find(this.moduleName, filter)
+        }
+    }
+
+    /**
+     * By default unpatch everything.
+     * Override to do something else.
+     */
+    unpatch() {
+        Patcher.unpatchAll(`BD:${this.moduleName}`);
+    }
+
+    /**
+     * Patch a function in a module
+     * @param {any} module Module to patch
+     * @param {String} fnName Name of the function to patch
+     * @param {Function} cb Callback
+     * @param {String} [when=after] before|after|instead
+     */
+    patch(module, fnName, cb, when = 'after') {
+        if (!['before', 'after', 'instead'].includes(when)) when = 'after';
+        return Patch(`BD:${this.moduleName}`, module)[when](fnName, cb.bind(this));
+    }
+
+    childPatch(module, fnName, child, cb, when = 'after') {
+        const last = child.pop();
+
+        this.patch(module, fnName, (component, args, retVal) => {
+            const unpatch = this.patch(child.reduce((obj, key) => obj[key], retVal), last, function(...args) {unpatch(); return cb.call(this, component, ...args);}, when);
+        });
+    }
+
+    /**
+     * Logger wraps
+     */
+    log(message) {
+        Logger.log(this.moduleName, message);
+    }
+
+    warn(message) {
+        Logger.warn(this.moduleName, message);
+    }
+
+    info(message) {
+        Logger.warn(this.moduleName, message);
+    }
+
+    debug(message) {
+        Logger.dbg(this.moduleName, message);
+    }
+}

client/src/builtin/ColoredText.js

@@ -0,0 +1,73 @@
+/**
+ * BetterDiscord Colored Text Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BuiltinModule from './BuiltinModule';
+
+import { Utils } from 'common';
+import { Settings, Reflection, ReactComponents, DiscordApi } from 'modules';
+
+export default new class ColoredText extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'ColoredText' }
+
+    get settingPath() { return ['ui', 'default', 'colored-text'] }
+
+    get intensityPath() { return ['ui', 'advanced', 'colored-text-intensity'] }
+
+    get intensitySetting() { return Settings.getSetting(...this.intensityPath) }
+
+    get intensity() { return 100 - this.intensitySetting.value }
+
+    get defaultColor() { return DiscordApi.UserSettings.theme == 'light' ? '#747f8d' : '#dcddde' }
+
+    constructor() {
+        super();
+        this._intensityUpdated = this._intensityUpdated.bind(this);
+    }
+
+    async enabled(e) {
+        this.intensitySetting.off('setting-updated', this._intensityUpdated);
+        this.intensitySetting.on('setting-updated', this._intensityUpdated);
+    }
+
+    disabled(e) {
+        this.intensitySetting.off('setting-updated', this._intensityUpdated);
+    }
+
+    rerenderPatchedComponents() {
+        if (this.MessageContent) this.MessageContent.forceUpdateAll();
+    }
+
+    /* Methods */
+    _intensityUpdated() {
+        this.MessageContent.forceUpdateAll();
+    }
+
+    /* Patches */
+    async applyPatches() {
+        if (this.patches.length) return;
+        this.MessageContent = await ReactComponents.getComponent('MessageContent');
+        this.patch(this.MessageContent.component.prototype, 'render', this.injectColoredText);
+    }
+
+    /**
+     * Set markup text colour to match role colour
+     */
+    injectColoredText(thisObject, args, originalReturn) {
+        const unpatch = this.patch(originalReturn.props, 'children', (obj, args, returnValue) => {
+            unpatch();
+            const { TinyColor } = Reflection.modules;
+            const markup = Utils.findInReactTree(returnValue, m => m && m.props && m.props.className && m.props.className.includes('da-markup'));
+            const roleColor = thisObject.props.message.colorString;
+            if (markup && roleColor) markup.props.style = {color: TinyColor.mix(roleColor, this.defaultColor, this.intensity)};
+        });
+    }
+}

client/src/builtin/E2EE/E2EE.js

@@ -0,0 +1,396 @@
+/**
+ * BetterDiscord E2EE Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Settings, Cache, Events } from 'modules';
+import BuiltinModule from '../BuiltinModule';
+import { Reflection, ReactComponents, DiscordApi, Security } from 'modules';
+import { VueInjector, Modals, Toasts } from 'ui';
+import { ClientLogger as Logger, ClientIPC } from 'common';
+import { request } from 'vendor';
+import { Utils } from 'common';
+import E2EEComponent from './E2EEComponent.vue';
+import E2EEMessageButton from './E2EEMessageButton.vue';
+import nodecrypto from 'node-crypto';
+
+const userMentionPattern = new RegExp(`<@!?([0-9]{10,})>`, 'g');
+const roleMentionPattern = new RegExp(`<@&([0-9]{10,})>`, 'g');
+const everyoneMentionPattern = new RegExp(`(?:\\s+|^)@everyone(?:\\s+|$)`);
+
+const START_DATE = new Date();
+const TEMP_KEY = 'temporarymasterkey';
+const ECDH_STORAGE = {};
+let seed;
+
+export default new class E2EE extends BuiltinModule {
+
+    /* Getters */
+
+    get moduleName() { return 'E2EE' }
+
+    get settingPath() { return ['security', 'default', 'e2ee'] }
+
+    get database() { return Settings.getSetting('security', 'e2eedb', 'e2ekvps').value }
+
+    constructor() {
+        super();
+        this.encryptNewMessages = true;
+        this.ecdhDate = START_DATE;
+        this.handlePublicKey = this.handlePublicKey.bind(this);
+        this.fetchMasterKey = this.fetchMasterKey.bind(this);
+    }
+
+    async enabled(e) {
+        await this.fetchMasterKey();
+        Events.on('discord:MESSAGE_CREATE', this.handlePublicKey);
+        Settings.getSetting('security', 'default', 'use-keytar').on('setting-updated', this.fetchMasterKey);
+    }
+
+    async disabled(e) {
+        Settings.getSetting('security', 'default', 'use-keytar').off('setting-updated', this.fetchMasterKey);
+        Events.off('discord:MESSAGE_CREATE', this.handlePublicKey);
+        const ctaComponent = await ReactComponents.getComponent('ChannelTextArea');
+        ctaComponent.forceUpdateAll();
+    }
+
+    /* Methods */
+    async fetchMasterKey() {
+        try {
+            if (Settings.get('security', 'default', 'use-keytar')) {
+                const master = await ClientIPC.getPassword('betterdiscord', 'master');
+                if (master) return this.setMaster(master);
+
+                if (Settings.getSetting('security', 'e2eedb', 'e2ekvps').items.length) {
+                    // Ask the user for their current password to save to the system keychain
+                    const currentMaster = await Modals.input('Save to System Keychain', 'Master Password', true).promise;
+                    await ClientIPC.setPassword('betterdiscord', 'master', currentMaster);
+                    return this.setMaster(currentMaster);
+                }
+
+                // Generate a new master password and save it to the system keychain
+                const newMaster = Security.randomBytes();
+                await ClientIPC.setPassword('betterdiscord', 'master', newMaster);
+                return this.setMaster(newMaster);
+            }
+
+            const newMaster = await Modals.input('Open Database', 'Master Password', true).promise;
+            return this.setMaster(newMaster);
+        } catch (err) {
+            Settings.getSetting(...this.settingPath).value = false;
+            Toasts.error('Invalid master password! E2EE Disabled');
+            Logger.err('E2EE', ['Error fetching master password', err]);
+        }
+    }
+
+    setMaster(key) {
+        seed = Security.randomBytes();
+        const newMaster = Security.encrypt(seed, key);
+        // TODO re-encrypt everything with new master
+        return (this.master = newMaster);
+    }
+
+    encrypt(key, content, prefix = '') {
+        if (!key) {
+            // Encrypt something with master
+            return Security.encrypt(Security.decrypt(seed, this.master), content);
+        }
+
+        if (!content) {
+            // Get key for current channel and encrypt
+            const haveKey = this.getKey(DiscordApi.currentChannel.id);
+            if (!haveKey) return 'nokey';
+            return Security.encrypt(Security.decrypt(seed, [this.master, haveKey]), key);
+        }
+        return prefix + Security.encrypt(key, content);
+    }
+
+    decrypt(key, content, prefix = '') {
+        return Security.decrypt(key, content, prefix);
+    }
+
+    async createHmac(data) {
+        const haveKey = this.getKey(DiscordApi.currentChannel.id);
+        if (!haveKey) return null;
+        return Security.createHmac(Security.decrypt(seed, [this.master, haveKey]), data);
+    }
+
+    getKey(channelId) {
+        const haveKey = this.database.find(kvp => kvp.value.key === channelId);
+        if (!haveKey) return null;
+        return haveKey.value.value;
+    }
+
+    setKey(channelId, key) {
+        const items = Settings.getSetting('security', 'e2eedb', 'e2ekvps').items;
+        const index = items.findIndex(kvp => kvp.value.key === channelId);
+        if (index > -1) {
+            items[index].value = { key: channelId, value: key };
+            return;
+        }
+        Settings.getSetting('security', 'e2eedb', 'e2ekvps').addItem({ value: { key: channelId, value: key } });
+    }
+
+    createKeyExchange(dmChannelID) {
+        if (ECDH_STORAGE.hasOwnProperty(dmChannelID)) return null;
+        ECDH_STORAGE[dmChannelID] = Security.createECDH();
+        setTimeout(() => {
+            if (ECDH_STORAGE.hasOwnProperty(dmChannelID)) {
+                delete ECDH_STORAGE[dmChannelID];
+                Toasts.error('Key exchange expired!');
+                if (this.preExchangeState) this.encryptNewMessages = this.preExchangeState;
+                this.preExchangeState = null;
+            }
+        }, 30000);
+        return Security.generateECDHKeys(ECDH_STORAGE[dmChannelID]);
+    }
+
+    publicKeyFor(dmChannelID) {
+        return Security.getECDHPublicKey(ECDH_STORAGE[dmChannelID]);
+    }
+
+    computeSecret(dmChannelID, otherKey) {
+        try {
+            const secret = Security.computeECDHSecret(ECDH_STORAGE[dmChannelID], otherKey);
+            delete ECDH_STORAGE[dmChannelID];
+            return Security.hash('sha384', secret, 'hex');
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    /* Patches */
+    async applyPatches() {
+        if (this.patches.length) return;
+
+        const { Dispatcher } = Reflection.modules;
+        this.patch(Dispatcher, 'dispatch', this.dispatcherPatch, 'before');
+        this.patchMessageContent();
+
+        const ChannelTextArea = await ReactComponents.getComponent('ChannelTextArea');
+        this.patchChannelTextArea(ChannelTextArea);
+        this.patchChannelTextAreaSubmit(ChannelTextArea);
+        ChannelTextArea.forceUpdateAll();
+    }
+
+    dispatcherPatch(_, [event]) {
+        if (!event || event.type !== 'MESSAGE_CREATE') return;
+
+        const key = this.getKey(event.message.channel_id);
+        if (!key) return; // We don't have a key for this channel
+
+        if (typeof event.message.content !== 'string') return; // Ignore any non string content
+        if (!event.message.content.startsWith('$:')) return; // Not an encrypted string
+        let decrypt;
+        try {
+            decrypt = this.decrypt(this.decrypt(this.decrypt(seed, this.master), key), event.message.content);
+        } catch (err) { return } // Ignore errors such as non empty
+
+        const { MessageParser, Permissions, DiscordConstants } = Reflection.modules;
+
+        const currentChannel = DiscordApi.Channel.fromId(event.message.channel_id).discordObject;
+
+        // Create a generic message object to parse mentions with
+        const parsed = MessageParser.parse(currentChannel, decrypt).content;
+
+        if (userMentionPattern.test(parsed))
+            event.message.mentions = parsed.match(userMentionPattern).map(m => { return { id: m.replace(/[^0-9]/g, '') } });
+        if (roleMentionPattern.test(parsed))
+            event.message.mention_roles = parsed.match(roleMentionPattern).map(m => m.replace(/[^0-9]/g, ''));
+        if (everyoneMentionPattern.test(parsed))
+            event.message.mention_everyone = Permissions.can(DiscordConstants.Permissions.MENTION_EVERYONE, currentChannel);
+    }
+
+    // TODO Received exchange should also expire if not accepted in time
+    async handlePublicKey(e) {
+        if (!DiscordApi.currentChannel) return;
+        if (DiscordApi.currentChannel.type !== 'DM') return;
+        const { id, content, author, channelId } = e.args;
+        if (author.id === DiscordApi.currentUser.id || channelId !== DiscordApi.currentChannel.id) return;
+
+        const [tagstart, begin, key, end, tagend] = content.split('\n');
+        if (begin !== '-----BEGIN PUBLIC KEY-----' || end !== '-----END PUBLIC KEY-----') return;
+
+        try {
+            await Modals.confirm('Key Exchange', `Key exchange request from: ${author.username}#${author.discriminator}`, 'Accept', 'Reject').promise;
+            // We already sent our key
+            if (!ECDH_STORAGE.hasOwnProperty(channelId)) {
+                const publicKeyMessage = `\`\`\`\n-----BEGIN PUBLIC KEY-----\n${this.createKeyExchange(channelId)}\n-----END PUBLIC KEY-----\n\`\`\``;
+                if (this.encryptNewMessages) this.encryptNewMessages = false;
+                Reflection.modules.DraftActions.saveDraft(channelId, publicKeyMessage);
+            }
+            const secret = this.computeSecret(channelId, key);
+            this.setKey(channelId, secret);
+            Toasts.success('Key exchange complete!');
+            if (this.preExchangeState) this.encryptNewMessages = this.preExchangeState;
+            this.preExchangeState = null;
+        } catch (err) {
+            console.log(err);
+            return;
+        }
+    }
+
+    async patchMessageContent() {
+        const MessageContent = await ReactComponents.getComponent('MessageContent');
+        this.patch(MessageContent.component.prototype, 'render', this.beforeRenderMessageContent, 'before');
+        this.childPatch(MessageContent.component.prototype, 'render', ['props', 'children'], this.afterRenderMessageContent);
+        MessageContent.forceUpdateAll();
+
+        const ImageWrapper = await ReactComponents.getComponent('ImageWrapper');
+        this.patch(ImageWrapper.component.prototype, 'render', this.beforeRenderImageWrapper, 'before');
+        ImageWrapper.forceUpdateAll();
+    }
+
+    beforeRenderMessageContent(component) {
+        if (!component.props || !component.props.message) return;
+
+        const key = this.getKey(component.props.message.channel_id);
+        if (!key) return; // We don't have a key for this channel
+
+        const Message = Reflection.module.byPrototypes('isMentioned');
+        const { MessageParser, Permissions, DiscordConstants } = Reflection.modules;
+        const currentChannel = DiscordApi.Channel.fromId(component.props.message.channel_id).discordObject;
+
+        if (typeof component.props.message.content !== 'string') return; // Ignore any non string content
+        if (!component.props.message.content.startsWith('$:')) return; // Not an encrypted string
+        let decrypt;
+        try {
+            decrypt = Security.decrypt(seed, [this.master, key, component.props.message.content]);
+        } catch (err) { return } // Ignore errors such as non empty
+
+        component.props.message.bd_encrypted = true; // signal as encrypted
+
+        // Create a generic message object to parse mentions with
+        const message = MessageParser.createMessage(currentChannel.id, MessageParser.parse(currentChannel, decrypt).content);
+
+        if (userMentionPattern.test(message.content))
+            message.mentions = message.content.match(userMentionPattern).map(m => { return { id: m.replace(/[^0-9]/g, '') } });
+        if (roleMentionPattern.test(message.content))
+            message.mention_roles = message.content.match(roleMentionPattern).map(m => m.replace(/[^0-9]/g, ''));
+        if (everyoneMentionPattern.test(message.content))
+            message.mention_everyone = Permissions.can(DiscordConstants.Permissions.MENTION_EVERYONE, currentChannel);
+
+        // Create a new message to parse it properly
+        const create = Message.create(message);
+        if (!create.content || !create.contentParsed) return;
+
+        component.props.message.mentions = create.mentions;
+        component.props.message.mentionRoles = create.mentionRoles;
+        component.props.message.mentionEveryone = create.mentionEveryone;
+        component.props.message.mentioned = create.mentioned;
+        component.props.message.content = create.content;
+        component.props.message.contentParsed = create.contentParsed;
+    }
+
+    afterRenderMessageContent(component, _childrenObject, args, retVal) {
+        if (!component.props.message.bd_encrypted) return;
+
+        const { className } = Reflection.resolve('buttonContainer', 'avatar', 'username');
+        const buttonContainer = Utils.findInReactTree(retVal, m => m && m.className && m.className.indexOf(className) !== -1);
+        if (!buttonContainer) return;
+
+        const buttons = buttonContainer.children.props.children;
+        if (!buttons) return;
+
+        try {
+            buttons.unshift(VueInjector.createReactElement(E2EEMessageButton));
+        } catch (err) {
+            Logger.err('E2EE', err.message);
+        }
+    }
+
+    beforeRenderImageWrapper(component, args, retVal) {
+        if (!component.props || !component.props.src) return;
+        if (component.props.decrypting) return;
+        component.props.decrypting = true;
+
+        const src = component.props.original || component.props.src.split('?')[0];
+        if (!src.includes('bde2ee')) return;
+        component.props.className = 'bd-encryptedImage';
+
+        const haveKey = this.getKey(DiscordApi.currentChannel.id);
+        if (!haveKey) return;
+
+        const cached = Cache.find('e2ee:images', item => item.src === src);
+        if (cached) {
+            if (cached.invalidKey) { // TODO If key has changed we should recheck all with invalid key
+                component.props.className = 'bd-encryptedImage bd-encryptedImageBadKey';
+                component.props.readyState = 'READY';
+                return;
+            }
+            Logger.info('E2EE', 'Returning encrypted image from cache');
+            try {
+                const decrypt = Security.decrypt(seed, [this.master, haveKey, cached.image]);
+                component.props.className = 'bd-decryptedImage';
+                component.props.src = component.props.original = `data:;base64,${decrypt}`;
+            } catch (err) { return } finally { component.props.readyState = 'READY' }
+            return;
+        }
+
+        component.props.readyState = 'LOADING';
+        Logger.info('E2EE', `Decrypting image: ${src}`);
+
+        (async () => {
+            try {
+                const res = await request.get(src, { encoding: 'binary' });
+
+                const arr = new Uint8Array(new ArrayBuffer(res.length));
+                for (let i = 0; i < res.length; i++) arr[i] = res.charCodeAt(i);
+
+                const aobindex = Utils.aobscan(arr, [73, 69, 78, 68]) + 8;
+                const sliced = arr.slice(aobindex);
+                const image = new TextDecoder().decode(sliced);
+
+                const hmac = image.slice(-64);
+                const data = image.slice(0, -64);
+                const validateHmac = await this.createHmac(data);
+                if (hmac !== validateHmac) {
+                    Cache.push('e2ee:images', { src, invalidKey: true });
+                    if (component && component.props) {
+                        component.props.decrypting = false;
+                        component.forceUpdate();
+                    }
+                    return;
+                }
+
+                Cache.push('e2ee:images', { src, image: data });
+
+                if (!component || !component.props) {
+                    Logger.warn('E2EE', 'Component seems to be gone');
+                    return;
+                }
+
+                component.props.decrypting = false;
+                component.forceUpdate();
+            } catch (err) {
+                console.log('request error', err);
+            }
+        })();
+    }
+
+    patchChannelTextArea(cta) {
+        this.patch(cta.component.prototype, 'render', this.renderChannelTextArea);
+    }
+
+    renderChannelTextArea(component, args, retVal) {
+        if (!(retVal.props.children instanceof Array)) retVal.props.children = [retVal.props.children];
+        const inner = retVal.props.children.find(child => child.props.className && child.props.className.includes('inner'));
+        inner.props.children.splice(0, 0, VueInjector.createReactElement(E2EEComponent));
+    }
+
+    patchChannelTextAreaSubmit(cta) {
+        this.patch(cta.component.prototype, 'handleSubmit', this.handleChannelTextAreaSubmit, 'before');
+    }
+
+    handleChannelTextAreaSubmit(component, args, retVal) {
+        const key = this.getKey(DiscordApi.currentChannel.id);
+        if (!this.encryptNewMessages || !key) return;
+        component.props.value = Security.encrypt(Security.decrypt(seed, [this.master, key]), component.props.value, '$:');
+    }
+
+}

client/src/builtin/E2EE/E2EEComponent.vue

@@ -0,0 +1,120 @@
+/**
+ * BetterDiscord E2EE Component
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+<template>
+    <div class="bd-e2eeTaContainer">
+        <v-popover :popoverClass="['bd-popover', 'bd-e2eePopover', {'bd-e2eePopoverOver': popoutPositionSetting.value === 'over'}]"
+            :trigger="popoutPositionSetting.value === 'over' && popoutTriggerSetting.value === 'hover' ? 'hover' : 'click'"
+            :placement="popoutPositionSetting.value === 'over' ? 'top-start' : 'top'"
+            :disabled="error && DiscordApi.currentChannel.type !== 'DM'">
+
+            <div v-if="error" class="bd-e2eeTaBtn bd-e2eeLock bd-error">
+                <MiLock v-tooltip="error" />
+            </div>
+            <div v-else-if="state === 'loading'" class="bd-e2eeTaBtn bd-e2eeLock bd-loading bd-warn">
+                <MiLock v-tooltip="'Loading'" />
+            </div>
+
+            <div v-else-if="!E2EE.encryptNewMessages" class="bd-e2eeTaBtn bd-e2eeLock bd-warn">
+                <MiLock v-tooltip="'New messages will not be encrypted.'" />
+            </div>
+
+            <div v-else class="bd-e2eeTaBtn bd-e2eeLock bd-ok">
+                <MiLock v-tooltip="'Ready!'" />
+            </div>
+
+            <template slot="popover">
+                <div @click="toggleEncrypt" :class="{'bd-warn': !E2EE.encryptNewMessages, 'bd-ok': E2EE.encryptNewMessages}"><MiLock v-tooltip="'Toggle Encryption'" /></div>
+                <div v-close-popover @click="showUploadDialog" v-if="!error"><MiImagePlus v-tooltip="'Upload Encrypted Image'" /></div>
+                <div v-close-popover @click="generatePublicKey" v-if="DiscordApi.currentChannel.type === 'DM'"><MiIcVpnKey v-tooltip="'Begin Key Exchange'" /></div>
+            </template>
+        </v-popover>
+        <div class="bd-taDivider"></div>
+    </div>
+</template>
+
+<script>
+    import { Utils, FileUtils, ClientIPC } from 'common';
+    import { E2EE } from 'builtin';
+    import { Settings, DiscordApi, Reflection } from 'modules';
+    import { Toasts } from 'ui';
+    import { MiLock, MiImagePlus, MiIcVpnKey } from 'commoncomponents';
+
+    export default {
+        components: {
+            MiLock, MiImagePlus, MiIcVpnKey
+        },
+        data() {
+            return {
+                E2EE,
+                DiscordApi,
+                state: 'loading',
+                error: null,
+                popoutPositionSetting: Settings.getSetting('security', 'e2ee-popout', 'position'),
+                popoutTriggerSetting: Settings.getSetting('security', 'e2ee-popout', 'trigger')
+            };
+        },
+        methods: {
+            async showUploadDialog() {
+                const dialogResult = await ClientIPC.send('bd-native-open', {properties: ['openFile']});
+                if (!dialogResult || !dialogResult.length) return;
+
+                const readFile = await FileUtils.readFileBuffer(dialogResult[0]);
+                const FileActions = Reflection.module.byProps('makeFile');
+                const Uploader = Reflection.module.byProps('instantBatchUpload');
+
+                const img = await Utils.getImageFromBuffer(readFile);
+
+                const canvas = document.createElement('canvas');
+                canvas.height = img.height;
+                canvas.width = img.width;
+                const arrBuffer = await Utils.canvasToArrayBuffer(canvas);
+                const encrypted = E2EE.encrypt(img.src.replace('data:;base64,', ''));
+                const hmac = await E2EE.createHmac(encrypted);
+                const encodedBytes = new TextEncoder().encode(encrypted + hmac);
+                Uploader.upload(DiscordApi.currentChannel.id, FileActions.makeFile(new Uint8Array([...new Uint8Array(arrBuffer), ...encodedBytes]), 'bde2ee.png'));
+            },
+            toggleEncrypt() {
+                const newState = !E2EE.encryptNewMessages;
+                E2EE.encryptNewMessages = newState;
+                if (!newState) {
+                    Toasts.warning('New messages will not be encrypted');
+                    return;
+                }
+                Toasts.success('New messages will be encrypted');
+            },
+            generatePublicKey() {
+                const keyExchange = E2EE.createKeyExchange(DiscordApi.currentChannel.id);
+                if (keyExchange === null) {
+                    Toasts.warning('Key exchange for channel already in progress!');
+                    return;
+                }
+                E2EE.preExchangeState = E2EE.encryptNewMessages;
+                E2EE.encryptNewMessages = false; // Disable encrypting new messages so we won't encrypt public keys
+                const publicKeyMessage = `\`\`\`\n-----BEGIN PUBLIC KEY-----\n${keyExchange}\n-----END PUBLIC KEY-----\n\`\`\``;
+                Reflection.modules.DraftActions.saveDraft(DiscordApi.currentChannel.id, publicKeyMessage);
+                Toasts.info('Key exchange started. Expires in 30 seconds');
+            }
+        },
+        mounted() {
+            if (!E2EE.master) {
+                this.error = 'No master key set!';
+                return;
+            }
+            const haveKey = E2EE.getKey(DiscordApi.currentChannel.id);
+            if (!haveKey) {
+                this.error = 'No key for channel!';
+                return;
+            }
+            this.state = 'OK';
+            this.error = null;
+        }
+    }
+</script>

client/src/builtin/E2EE/E2EEMessageButton.vue

@@ -1,5 +1,5 @@
-                                                         /**
- * BetterDiscord UI Settings Component
+/**
+ * BetterDiscord E2EE Component
  * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
  * All rights reserved.
  * https://betterdiscord.net
@@ -9,19 +9,20 @@
 */
 
 <template>
-    <SettingsWrapper headertext="UI Settings">
-    </SettingsWrapper>
+    <div class="bd-e2eeMessageButtonWrap">
+        <div class="bd-e2eeMessageButton">
+            <MiLock v-tooltip="'Encrypted'" :size="16" />
+        </div>
+    </div>
 </template>
 
 <script>
-    // Imports
-    import { SettingsWrapper } from './';
-    import { SettingSwitch } from '../common';
+    import { MiLock } from 'commoncomponents';
 
     export default {
         components: {
-            SettingsWrapper,
-            SettingSwitch
-        }
+            MiLock
+        },
+        props: ['message']
     }
 </script>

client/src/builtin/E2EE/index.js

@@ -0,0 +1,3 @@
+export { default as default } from './E2EE';
+export { default as E2EEComponent } from './E2EEComponent.vue';
+export { default as E2EEMessageButton } from './E2EEMessageButton.vue';

client/src/builtin/Emotes/EmoteAc.js

@@ -0,0 +1,104 @@
+/**
+ * BetterDiscord Emote Autocomplete Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Settings } from 'modules';
+import BuiltinModule from '../BuiltinModule';
+import EmoteModule, { EMOTE_SOURCES } from './EmoteModule';
+import GlobalAc from 'autocomplete';
+import { BdContextMenu } from 'ui';
+
+export default new class EmoteAc extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'EmoteAC' }
+    get settingPath() { return ['emotes', 'default', 'emoteac'] }
+
+    async enabled(e) {
+        GlobalAc.add(';', this);
+        window.removeEventListener('contextmenu', this.acCm);
+        window.addEventListener('contextmenu', this.acCm);
+    }
+
+    disabled(e) {
+        GlobalAc.remove(';');
+        window.removeEventListener('contextmenu', this.acCm);
+    }
+
+    /* Methods */
+    acCm(e) {
+        const row = e.target.closest('.bd-emotAc');
+        if (!row) return;
+        const img = row.querySelector('img');
+        if (!img || !img.alt) return;
+
+        BdContextMenu.show(e, [
+            {
+                text: 'Test',
+                items: [
+                    {
+                        text: 'Favourite',
+                        type: 'toggle',
+                        checked: EmoteModule.isFavourite(img.alt.replace(/;/g, '')),
+                        onChange: checked => {
+                            if (!img || !img.alt) return;
+                            const emote = img.alt.replace(/;/g, '');
+                            if (!checked) return EmoteModule.removeFavourite(emote), false;
+                            return EmoteModule.addFavourite(emote), true;
+                        }
+                    }
+                ]
+            }
+        ]);
+    }
+
+    /**
+     * Search for autocomplete
+     * @param {any} regex
+     */
+    acsearch(regex) {
+        const acType = Settings.getSetting('emotes', 'default', 'emoteactype').value;
+        if (regex.length <= 0) {
+            return {
+                type: 'imagetext',
+                title: [`Your ${acType ? 'most used' : 'favourite'} emotes`, '', `⬅ ${acType ? 'Favourites' : 'Most Used'} ⮕`],
+                items: EmoteModule[acType ? 'mostUsed' : 'favourites'].sort((a, b) => b.useCount - a.useCount).map(mu => {
+                    return {
+                        key: acType ? mu.key : mu.name,
+                        value: {
+                            src: EMOTE_SOURCES[mu.type].replace(':id', mu.id),
+                            replaceWith: `;${acType ? mu.key : mu.name};`,
+                            hint: mu.useCount ? `Used ${mu.useCount} times` : null
+                        }
+                    }
+                }),
+                extraClasses: ['bd-emotAc']
+            }
+        }
+
+        const results = EmoteModule.search(regex);
+        return {
+            type: 'imagetext',
+            title: ['Matching', regex.length],
+            items: results.map(result => {
+                result.value.src = EMOTE_SOURCES[result.value.type].replace(':id', result.value.id);
+                result.value.replaceWith = `;${result.key};`;
+                return result;
+            }),
+            extraClasses: ['bd-emotAc']
+        }
+    }
+
+    toggle(sterm) {
+        if (sterm.length > 1) return false;
+        Settings.getSetting('emotes', 'default', 'emoteactype').value = !Settings.getSetting('emotes', 'default', 'emoteactype').value;
+        return true;
+    }
+
+}

client/src/builtin/Emotes/EmoteComponent.js

@@ -0,0 +1,41 @@
+/**
+ * BetterDiscord Emote Component
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import VrWrapper from '../../ui/vrwrapper';
+import { EMOTE_SOURCES } from '.';
+import EmoteComponent from './EmoteComponent.vue';
+
+export default class Emote extends VrWrapper {
+
+    constructor(type, id, name) {
+        super();
+        this.jumboable = false;
+        this.type = type;
+        this.id = id;
+        this.name = name;
+    }
+
+    get component() { return EmoteComponent }
+
+    get props() {
+        return {
+            src: this.parseSrc(),
+            name: this.name,
+            jumboable: this.jumboable
+        }
+    }
+
+    parseSrc() {
+        const { type, id } = this;
+        if (type > 2 || type < 0) return '';
+        return EMOTE_SOURCES[type].replace(':id', id);
+    }
+
+}

client/src/builtin/Emotes/EmoteComponent.vue

@@ -0,0 +1,32 @@
+<template>
+    <img class="bd-emote emoji" :class="{jumboable}" :src="src" :alt="`;${name};`" v-tooltip="{ content: `;${name};`, delay: { show: 750, hide: 0 } }" />
+</template>
+
+<script>
+    import { ClientLogger as Logger } from 'common';
+    import EmoteModule from './EmoteModule';
+    import { MiStar } from 'commoncomponents';
+
+    export default {
+        components: {
+            MiStar
+        },
+        props: ['src', 'name', 'hasWrapper', 'jumboable'],
+        data() {
+            return {
+                EmoteModule
+            };
+        },
+        computed: {
+            favourite() {
+                return false;
+            }
+        },
+        methods: {
+            async toggleFavourite() {
+                await EmoteModule.setFavourite(this.name, !this.favourite);
+                Logger.log('EmoteComponent', `Set emote ${this.name} as ${this.favourite ? '' : 'un'}favourite`);
+            }
+        }
+    }
+</script>

client/src/builtin/Emotes/EmoteModule.js

@@ -0,0 +1,406 @@
+/**
+ * BetterDiscord Emote Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BuiltinModule from '../BuiltinModule';
+import path from 'path';
+import { request } from 'vendor';
+
+import { Utils, FileUtils, ClientLogger as Logger } from 'common';
+import { DiscordApi, Settings, Globals, Reflection, ReactComponents, Database } from 'modules';
+import { DiscordContextMenu } from 'ui';
+
+import Emote from './EmoteComponent.js';
+
+export const EMOTE_SOURCES = [
+    'https://static-cdn.jtvnw.net/emoticons/v1/:id/1.0',
+    'https://cdn.frankerfacez.com/emoticon/:id/1',
+    'https://cdn.betterttv.net/emote/:id/1x'
+];
+
+export default new class EmoteModule extends BuiltinModule {
+
+    /* Getters */
+
+    get moduleName() { return 'EmoteModule' }
+
+    /**
+     * @returns {String} Path to local emote database
+     */
+    get dbpath() { return path.join(Globals.getPath('data'), 'emotes.json') }
+
+    /**
+     * @returns {Map} Cached raw emote database
+     */
+    get database() { return this._db || (this._db = new Map()) }
+
+    /**
+     * @returns {Array} Favourite emotes
+     */
+    get favourites() { return this._favourites || (this._favourites = []) }
+
+    /**
+     * @returns {Array} Most used emotes
+     */
+    get mostUsed() { return this._mostUsed || (this._mostUsed = []) }
+
+    get settingPath() { return ['emotes', 'default', 'enable'] }
+
+    async enabled() {
+        // Add favourite button to context menu
+        this.favCm = DiscordContextMenu.add(target => [
+            {
+                text: 'Favourite',
+                type: 'toggle',
+                checked: target && target.alt && this.isFavourite(target.alt.replace(/;/g, '')),
+                onChange: (checked, target) => {
+                    const { alt } = target;
+                    if (!alt) return false;
+
+                    const emote = alt.replace(/;/g, '');
+
+                    if (!checked) return this.removeFavourite(emote), false;
+                    return this.addFavourite(emote), true;
+                }
+            }
+        ], target => target.closest('.bd-emote'));
+
+        if (!this.database.size) {
+            await this.loadLocalDb();
+        }
+
+        // Read favourites and most used from database
+        await this.loadUserData();
+    }
+
+    async disabled() {
+        DiscordContextMenu.remove(this.favCm);
+    }
+
+    /* Methods */
+
+    /**
+     * Adds an emote to favourites.
+     * @param {Object|String} emote
+     * @return {Promise}
+     */
+    addFavourite(emote) {
+        if (this.isFavourite(emote)) return;
+        if (typeof emote === 'string') emote = this.findByName(emote, true);
+        this.favourites.push(emote);
+        return this.saveUserData();
+    }
+
+    /**
+     * Removes an emote from favourites.
+     * @param {Object|String} emote
+     * @return {Promise}
+     */
+    removeFavourite(emote) {
+        if (!this.isFavourite(emote)) return;
+        Utils.removeFromArray(this.favourites, e => e.name === emote || e.name === emote.name, true);
+        return this.saveUserData();
+    }
+
+    /**
+     * Checks if an emote is in favourites.
+     * @param {Object|String} emote
+     * @return {Boolean}
+     */
+    isFavourite(emote) {
+        return !!this.favourites.find(e => e.name === emote || e.name === emote.name);
+    }
+
+    /**
+     * Load emotes from local database
+     */
+    async loadLocalDb() {
+        const emotes = await FileUtils.readJsonFromFile(this.dbpath);
+        for (const [index, emote] of emotes.entries()) {
+            const { type, id, src, value } = emote;
+            if (index % 10000 === 0) await Utils.wait();
+
+            this.database.set(id, { id: emote.value.id || value, type });
+        }
+
+        Logger.log('EmoteModule', ['Loaded emote database']);
+    }
+
+    async loadUserData() {
+        const userData = await Database.findOne({ type: 'builtin', id: 'EmoteModule' });
+        if (!userData) return;
+
+        if (userData.hasOwnProperty('favourites')) this._favourites = userData.favourites;
+        if (userData.hasOwnProperty('mostused')) this._mostUsed = userData.mostused;
+    }
+
+    async saveUserData() {
+        await Database.insertOrUpdate({ type: 'builtin', id: 'EmoteModule' }, {
+            type: 'builtin',
+            id: 'EmoteModule',
+            favourites: this.favourites,
+            mostused: this.mostUsed
+        });
+    }
+
+    /**
+     * Add/update emote to most used
+     * @param {Object} emote emote to add/update
+     * @return {Promise}
+     */
+    addToMostUsed(emote) {
+        const isMostUsed = this.mostUsed.find(mu => mu.key === emote.name);
+        if (isMostUsed) {
+            isMostUsed.useCount += 1;
+        } else {
+            this.mostUsed.push({
+                key: emote.name,
+                id: emote.id,
+                type: emote.type,
+                useCount: 1
+            });
+        }
+        // Save most used to database
+        // TODO only save first n
+        return this.saveUserData();
+    }
+
+    /**
+     * Find an emote by name
+     * @param {String} name Emote name
+     * @param {Boolean} simple Simple object or Emote instance
+     * @returns {Object|Emote}
+     */
+    findByName(name, simple = false) {
+        const emote = this.database.get(name);
+        if (!emote) return null;
+        return this.parseEmote(name, emote, simple);
+    }
+
+    /**
+     * Parse emote object
+     * @param {String} name Emote name
+     * @param {Object} emote Emote object
+     * @param {Boolean} simple Simple object or Emote instance
+     * @returns {Object|Emote}
+     */
+    parseEmote(name, emote, simple = false) {
+        const { type, id } = emote;
+        if (type < 0 || type > 2) return null;
+        return simple ? { type, id, name } : new Emote(type, id, name);
+    }
+
+    /**
+     * Search for anything else
+     * @param {any} regex
+     * @param {any} limit
+     */
+    search(regex, limit = 10) {
+        if (typeof regex === 'string') regex = new RegExp(regex, 'i');
+        const matching = [];
+
+        for (const [key, value] of this.database.entries()) {
+            if (matching.length >= limit) break;
+            if (regex.test(key)) matching.push({ key, value })
+        }
+
+        return matching;
+    }
+
+    /* Patches */
+    async applyPatches() {
+        this.patchMessageContent();
+        this.patchSendAndEdit();
+        this.patchSpoiler();
+
+        const MessageAccessories = await ReactComponents.getComponent('MessageAccessories');
+        this.patch(MessageAccessories.component.prototype, 'render', this.afterRenderMessageAccessories, 'after');
+        MessageAccessories.forceUpdateAll();
+    }
+
+    /**
+     * Patches MessageContent render method
+     */
+    async patchMessageContent() {
+        const MessageContent = await ReactComponents.getComponent('MessageContent');
+        this.childPatch(MessageContent.component.prototype, 'render', ['props', 'children'], this.afterRenderMessageContent);
+        MessageContent.forceUpdateAll();
+    }
+
+    /**
+     * Patches MessageActions send and edit
+     */
+    patchSendAndEdit() {
+        const { MessageActions } = Reflection.modules;
+        this.patch(MessageActions, 'sendMessage', this.handleSendMessage, 'instead');
+        this.patch(MessageActions, 'editMessage', this.handleEditMessage, 'instead');
+    }
+
+    async patchSpoiler() {
+        const Spoiler = await ReactComponents.getComponent('Spoiler');
+        this.childPatch(Spoiler.component.prototype, 'render', ['props', 'children', 'props', 'children'], this.afterRenderSpoiler);
+        Spoiler.forceUpdateAll();
+    }
+
+    afterRenderSpoiler(component, _childrenObject, args, retVal) {
+        const markup = Utils.findInReactTree(retVal, filter =>
+            filter &&
+            filter.className &&
+            filter.className.includes('inlineContent'));
+        if (!markup) return;
+
+        markup.children = this.processMarkup(markup.children);
+    }
+
+    /**
+     * Handle message render
+     */
+    afterRenderMessageContent(component, _childrenObject, args, retVal) {
+        const markup = Utils.findInReactTree(retVal, filter =>
+            filter &&
+            filter.className &&
+            filter.className.includes('markup') &&
+            filter.children.length >= 2);
+        if (!markup) return;
+        markup.children[1] = this.processMarkup(markup.children[1]);
+    }
+
+    /**
+     * Handle send message
+     */
+    async handleSendMessage(MessageActions, args, orig) {
+        if (!args.length) return orig(...args);
+        const { content } = args[1];
+        if (!content) return orig(...args);
+
+        Logger.log('EmoteModule', ['Sending message', MessageActions, args, orig]);
+
+        const emoteAsImage = Settings.getSetting('emotes', 'default', 'emoteasimage').value &&
+            (DiscordApi.currentChannel.type === 'DM' || DiscordApi.currentChannel.type === 'GROUP_DM' || DiscordApi.currentChannel.checkPermissions(DiscordApi.modules.DiscordPermissions.ATTACH_FILES));
+
+        if (!emoteAsImage || content.split(' ').length > 1) {
+            args[1].content = args[1].content.split(' ').map(word => {
+                const isEmote = /;(.*?);/g.exec(word);
+                if (isEmote) {
+                    const emote = this.findByName(isEmote[1], true);
+                    if (!emote) return word;
+                    this.addToMostUsed(emote);
+                    return emote ? `;${isEmote[1]};` : word;
+                }
+                return word;
+            }).join(' ');
+            return orig(...args);
+        }
+
+        const isEmote = /;(.*?);/g.exec(content);
+        if (!isEmote) return orig(...args);
+
+        const emote = this.findByName(isEmote[1]);
+        if (!emote) return orig(...args);
+        this.addToMostUsed(emote);
+
+        const FileActions = Reflection.module.byProps('makeFile');
+        const Uploader = Reflection.module.byProps('instantBatchUpload');
+
+        request.get(emote.props.src, { encoding: 'binary' }).then(res => {
+            const arr = new Uint8Array(new ArrayBuffer(res.length));
+            for (let i = 0; i < res.length; i++) arr[i] = res.charCodeAt(i);
+            const suffix = arr[0] === 71 && arr[1] === 73 && arr[2] === 70 ? '.gif' : '.png';
+            Uploader.upload(args[0], FileActions.makeFile(arr, `${emote.name}.bdemote${suffix}`));
+        });
+    }
+
+    /**
+     * Handle edit message
+     */
+    handleEditMessage(component, args, orig) {
+        if (!args.length) return orig(...args);
+        const { content } = args[2];
+        if (!content) return orig(...args);
+        args[2].content = args[2].content.split(' ').map(word => {
+            const isEmote = /;(.*?);/g.exec(word);
+            return isEmote ? `;${isEmote[1]};` : word;
+        }).join(' ');
+        return orig(...args);
+    }
+
+    /**
+     * Handle MessageAccessories render
+     */
+    afterRenderMessageAccessories(component, args, retVal) {
+        if (!component.props || !component.props.message) return;
+        if (!component.props.message.attachments || component.props.message.attachments.length !== 1) return;
+
+        const filename = component.props.message.attachments[0].filename;
+        const match = filename.match(/([^/]*)\.bdemote\.(gif|png)$/i);
+        if (!match) return;
+
+        const emote = this.findByName(match[1]);
+        if (!emote) return;
+
+        emote.jumboable = true;
+        retVal.props.children[2] = emote.render();
+    }
+
+    /**
+     * Inject emotes into markup
+     */
+    processMarkup(markup) {
+        const newMarkup = [];
+        if (!(markup instanceof Array)) return markup;
+
+        const jumboable = !markup.some(child => {
+            if (typeof child !== 'string') return false;
+            return / \w+/g.test(child);
+        });
+
+        for (const child of markup) {
+            if (typeof child !== 'string') {
+                if (typeof child === 'object') {
+                    const isEmoji = Utils.findInReactTree(child, filter => filter && filter.emojiName);
+                    if (isEmoji) isEmoji.jumboable = jumboable;
+                }
+                newMarkup.push(child);
+                continue;
+            }
+
+            if (!/;(\w+);/g.test(child)) {
+                newMarkup.push(child);
+                continue;
+            }
+
+            const words = child.split(/([^\s]+)([\s]|$)/g).filter(f => f !== '');
+
+            let s = '';
+            for (const word of words) {
+                const isemote = /;(.*?);/g.exec(word);
+                if (!isemote) {
+                    s += word;
+                    continue;
+                }
+
+                const emote = this.findByName(isemote[1]);
+                if (!emote) {
+                    s += word;
+                    continue;
+                }
+
+                newMarkup.push(s);
+                s = '';
+
+                emote.jumboable = jumboable;
+                newMarkup.push(emote.render());
+            }
+            if (s !== '') newMarkup.push(s);
+        }
+        if (newMarkup.length === 1) return newMarkup[0];
+        return newMarkup;
+    }
+
+}

client/src/builtin/Emotes/index.js

@@ -0,0 +1,4 @@
+export { default as EmoteModule, EMOTE_SOURCES } from './EmoteModule';
+export { default as Emote } from './EmoteComponent';
+export { default as EmoteComponent } from './EmoteComponent.vue';
+export { default as EmoteAc } from './EmoteAc';

client/src/builtin/KillClyde.js

@@ -0,0 +1,28 @@
+/**
+ * BetterDiscord Kill Clyde Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BuiltinModule from './BuiltinModule';
+import { Reflection } from 'modules';
+
+export default new class KillClyde extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'KillClyde' }
+
+    get settingPath() { return ['ui', 'default', 'kill-clyde'] }
+
+    /* Patches */
+    applyPatches() {
+        if (this.patches.length) return;
+        const { MessageActions } = Reflection.modules;
+        this.patch(MessageActions, 'sendBotMessage', () => void 0, 'instead');
+    }
+
+}

client/src/builtin/Manager.js

@@ -0,0 +1,30 @@
+import { EmoteModule, EmoteAc } from './Emotes';
+import ReactDevtoolsModule from './ReactDevtoolsModule';
+import VueDevtoolsModule from './VueDevToolsModule';
+import TrackingProtection from './TrackingProtection';
+import E2EE from './E2EE';
+import ColoredText from './ColoredText';
+import TwentyFourHour from './24Hour';
+import KillClyde from './KillClyde';
+import BlockedMessages from './BlockedMessages';
+import VoiceDisconnect from './VoiceDisconnect';
+
+export default class {
+    static get modules() {
+        return require('./builtin');
+    }
+
+    static initAll() {
+        EmoteModule.init();
+        ReactDevtoolsModule.init();
+        VueDevtoolsModule.init();
+        TrackingProtection.init();
+        E2EE.init();
+        ColoredText.init();
+        TwentyFourHour.init();
+        KillClyde.init();
+        BlockedMessages.init();
+        VoiceDisconnect.init();
+        EmoteAc.init();
+    }
+}

client/src/builtin/ReactDevtoolsModule.js

@@ -0,0 +1,55 @@
+/**
+ * BetterDiscord React Devtools Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import electron from 'electron';
+import path from 'path';
+
+import BuiltinModule from './BuiltinModule';
+
+import { Globals } from 'modules';
+import { Toasts } from 'ui';
+
+export default new class ReactDevtoolsModule extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'ReactDevTools' }
+
+    get settingPath() { return ['core', 'advanced', 'react-devtools'] }
+
+    constructor() {
+        super();
+        this.devToolsOpened = this.devToolsOpened.bind(this);
+    }
+
+    enabled(e) {
+        electron.remote.getCurrentWindow().webContents.on('devtools-opened', this.devToolsOpened);
+        if (electron.remote.getCurrentWindow().isDevToolsOpened) this.devToolsOpened();
+    }
+
+    disabled(e) {
+        electron.remote.BrowserWindow.removeDevToolsExtension('React Developer Tools');
+        electron.remote.getCurrentWindow().webContents.removeListener('devtools-opened', this.devToolsOpened);
+    }
+
+    devToolsOpened() {
+        electron.remote.BrowserWindow.removeDevToolsExtension('React Developer Tools');
+
+        try {
+            const res = electron.remote.BrowserWindow.addDevToolsExtension(path.join(Globals.getPath('ext'), 'extensions', 'rdt'));
+            if (res !== undefined) {
+                Toasts.success(`${res} Installed`);
+                return;
+            }
+            Toasts.error('React Developer Tools install failed');
+        } catch (err) {
+            Toasts.error('React Developer Tools install failed');
+        }
+    }
+}

client/src/builtin/TrackingProtection.js

@@ -0,0 +1,36 @@
+/**
+ * BetterDiscord Tracking Protection Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BuiltinModule from './BuiltinModule';
+
+import { Reflection } from 'modules';
+
+export default new class TrackingProtection extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'TrackingProtection' }
+
+    get settingPath() { return ['security', 'default', 'tracking-protection'] }
+
+    /* Patches */
+    applyPatches() {
+        if (this.patches.length) return;
+        const TrackingModule = Reflection.module.byProps('track');
+        if (!TrackingModule) {
+            this.warn('Tracking module not found!');
+            return;
+        }
+        this.patch(TrackingModule, 'track', this.track, 'instead');
+    }
+
+    track(e) {
+        this.debug('Tracking blocked');
+    }
+}

client/src/builtin/VoiceDisconnect.js

@@ -0,0 +1,35 @@
+/**
+ * BetterDiscord Voice Disconnect Timestamps Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BuiltinModule from './BuiltinModule';
+import { Reflection } from 'modules';
+
+export default new class VoiceDisconnect extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'VoiceDisconnect' }
+
+    get settingPath() { return ['core', 'default', 'voice-disconnect'] }
+
+    async enabled(e) {
+        window.addEventListener('beforeunload', this.listener);
+    }
+
+    disabled(e) {
+        window.removeEventListener('beforeunload', this.listener);
+    }
+
+    /* Methods */
+    listener() {
+        const { VoiceChannelActions } = Reflection.modules;
+        VoiceChannelActions.selectVoiceChannel(null, null);
+    }
+
+}

client/src/builtin/VueDevToolsModule.js

@@ -0,0 +1,55 @@
+/**
+ * BetterDiscord Vue Devtools Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import electron from 'electron';
+import path from 'path';
+
+import BuiltinModule from './BuiltinModule';
+
+import { Globals } from 'modules';
+import { Toasts } from 'ui';
+
+export default new class VueDevtoolsModule extends BuiltinModule {
+
+    /* Getters */
+    get moduleName() { return 'VueDevTools' }
+
+    get settingPath() { return ['core', 'advanced', 'vue-devtools'] }
+
+    constructor() {
+        super();
+        this.devToolsOpened = this.devToolsOpened.bind(this);
+    }
+
+    enabled(e) {
+        electron.remote.getCurrentWindow().webContents.on('devtools-opened', this.devToolsOpened);
+        if (electron.remote.getCurrentWindow().isDevToolsOpened) this.devToolsOpened();
+    }
+
+    disabled(e) {
+        electron.remote.BrowserWindow.removeDevToolsExtension('Vue.js devtools');
+        electron.remote.getCurrentWindow().webContents.removeListener('devtools-opened', this.devToolsOpened);
+    }
+
+    devToolsOpened() {
+        electron.remote.BrowserWindow.removeDevToolsExtension('Vue.js devtools');
+
+        try {
+            const res = electron.remote.BrowserWindow.addDevToolsExtension(path.join(Globals.getPath('ext'), 'extensions', 'vdt'));
+            if (res !== undefined) {
+                Toasts.success(`${res} Installed`);
+                return;
+            }
+            Toasts.error('Vue.js devtools install failed');
+        } catch (err) {
+            Toasts.error('Vue.js devtools install failed');
+        }
+    }
+}

client/src/builtin/builtin.js

@@ -0,0 +1,11 @@
+export { EmoteModule, EmoteAc } from './Emotes';
+export { default as ReactDevtoolsModule } from './ReactDevtoolsModule';
+export { default as VueDevtoolsModule } from './VueDevToolsModule';
+export { default as TrackingProtection } from './TrackingProtection';
+export { default as BuiltinManager } from './Manager';
+export { default as E2EE } from './E2EE';
+export { default as ColoredText } from './ColoredText';
+export { default as TwentyFourHour } from './24Hour';
+export { default as KillClyde } from './KillClyde';
+export { default as BlockedMessages } from './BlockedMessages';
+export { default as VoiceDisconnect } from './VoiceDisconnect';

client/src/data/contributors.json

@@ -0,0 +1,79 @@
+[
+    {
+        "__user": "Jiiks#5000",
+        "id": "81388395867156480",
+        "developer": true,
+        "webdev": true,
+        "contributor": true
+    },
+    {
+        "__user": "Pohky#0156",
+        "id": "98003542823944192",
+        "developer": true,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "Hammock#3110",
+        "id": "138850472541814784",
+        "developer": false,
+        "webdev": true,
+        "contributor": true
+    },
+    {
+        "__user": "Zerebos#7790",
+        "id": "249746236008169473",
+        "developer": true,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "Pierce#1337",
+        "id": "125367412370440192",
+        "developer": true,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "Samuel Elliott#2764",
+        "id": "284056145272766465",
+        "developer": true,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "Lilian Tedone#6223",
+        "id": "184021060562321419",
+        "developer": false,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "samfun123#8972",
+        "id": "76052829285916672",
+        "developer": false,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "samogot#4379",
+        "id": "171005991272316937",
+        "developer": false,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "Lucario 🌌 V5.0.0#7902",
+        "id": "438469378418409483",
+        "developer": false,
+        "webdev": false,
+        "contributor": true
+    },
+    {
+        "__user": "Maks#3712",
+        "id": "340975736037048332",
+        "developer": false,
+        "webdev": false,
+        "contributor": true
+    }
+]

client/src/data/user.settings.default.json

@@ -2,54 +2,310 @@
     {
         "id": "core",
         "text": "Core",
+        "headertext": "Core Settings",
         "settings": [
             {
-                "id": "test-setting",
-                "text": "Test Setting",
-                "hint": "Test Setting",
-                "enabled": false,
-                "disabled": false
+                "id": "default",
+                "settings": [
+                    {
+                        "id": "voice-disconnect",
+                        "type": "bool",
+                        "text": "Voice Disconnect",
+                        "hint": "Disconnect from voice server when Discord closes",
+                        "value": false
+                    },
+                    {
+                        "id": "menu-keybind",
+                        "type": "keybind",
+                        "text": "Menu keybind",
+                        "value": "mod+b"
+                    }
+                ]
             },
             {
-                "id": "test-setting2",
-                "text": "Test Setting 2",
-                "hint": "Test Setting 2",
-                "enabled": true,
-                "disabled": false
+                "id": "advanced",
+                "name": "Advanced",
+                "type": "drawer",
+                "settings": [
+                    {
+                        "id": "developer-mode",
+                        "type": "bool",
+                        "text": "Developer mode",
+                        "hint": "Adds some of BetterDiscord's internal modules to `global._bd`.",
+                        "value": false
+                    },
+                    {
+                        "id": "debugger-keybind",
+                        "type": "keybind",
+                        "text": "Debugger keybind",
+                        "hint": "Open developer tools and pause"
+                    },
+                    {
+                        "id": "ignore-content-manager-errors",
+                        "type": "bool",
+                        "text": "Ignore content manager errors",
+                        "hint": "Only when starting Discord. It gets annoying when you're reloading Discord often and have plugins that are meant to fail.",
+                        "value": false
+                    },
+                    {
+                        "id": "react-devtools",
+                        "type": "bool",
+                        "text": "React Developer Tools",
+                        "hint": "Place extension in ext/extensions/rdt",
+                        "value": false
+                    },
+                    {
+                        "id": "vue-devtools",
+                        "type": "bool",
+                        "text": "Vue Developer Tools",
+                        "hint": "Place extension in ext/extensions/vdt",
+                        "value": false
+                    }
+                ]
             },
             {
-                "id": "voice-disconnect",
-                "text": "Voice Disconnect",
-                "hint": "Disconnect from voice server when Discord closes",
-                "enabled": false,
-                "disabled": true
-            },
-            {
-                "id": "developer-mode",
-                "text": "Developer Mode",
-                "hint": "BetterDiscord developer mode",
-                "enabled": false,
-                "disabled": true
+                "id": "window-preferences",
+                "name": "Window Preferences",
+                "type": "drawer",
+                "settings": [
+                    {
+                        "id": "window-preferences",
+                        "type": "custom",
+                        "component": "WindowPreferences"
+                    }
+                ]
             }
         ]
     },
     {
         "id": "ui",
         "text": "UI",
+        "headertext": "UI Settings",
         "settings": [
-
+            {
+                "id": "default",
+                "settings": [
+                    {
+                        "id": "hide-button",
+                        "type": "bool",
+                        "text": "Hide the BetterDiscord button",
+                        "hint": "When this is enabled you can use Ctrl/Cmd + B to open the BetterDiscord settings menu.",
+                        "value": false,
+                        "disabled": false
+                    },
+                    {
+                        "id": "enable-toasts",
+                        "type": "bool",
+                        "text": "Enable Toasts",
+                        "hint": "Allows plugins to show toasts.",
+                        "value": true
+                    },
+                    {
+                        "id": "colored-text",
+                        "type": "bool",
+                        "text": "Colored Text",
+                        "hint": "Colors messages to match the user's role color.",
+                        "value": false
+                    },
+                    {
+                        "id": "24-hour",
+                        "type": "bool",
+                        "text": "24 Hour Timestamps",
+                        "hint": "Replaces 12 hour timestamps with proper ones.",
+                        "value": false
+                    },
+                    {
+                        "id": "kill-clyde",
+                        "type": "bool",
+                        "text": "Kill Clyde",
+                        "hint": "Prevents Clyde from sending you error messages.",
+                        "value": false
+                    },
+                    {
+                        "id": "blocked-messages",
+                        "type": "bool",
+                        "text": "Prevent Blocked Messages",
+                        "hint": "Hides blocked messages in chat and even hides the new message notification.",
+                        "value": false
+                    }
+                ]
+            },
+            {
+                "id": "advanced",
+                "name": "Advanced",
+                "type": "drawer",
+                "settings": [
+                    {
+                        "id": "colored-text-intensity",
+                        "type": "slider",
+                        "text": "Colored Text Intensity",
+                        "hint": "Intensity of the colored text setting.",
+                        "value": 100,
+                        "min": 0,
+                        "max": 100,
+                        "step": 1,
+                        "unit": "%"
+                    }
+                ]
+            }
         ]
     },
     {
         "id": "emotes",
         "text": "Emotes",
-        "settings": []
+        "headertext": "Emote Settings",
+        "settings": [
+            {
+                "id": "default",
+                "settings": [
+                    {
+                        "id": "enable",
+                        "type": "bool",
+                        "text": "Enable emotes",
+                        "value": true
+                    },
+                    {
+                        "id": "emoteasimage",
+                        "type": "bool",
+                        "text": "Image Emote",
+                        "hint": "Send single emotes as images if you have the permission",
+                        "value": true
+                    },
+                    {
+                        "id": "emoteac",
+                        "type": "bool",
+                        "text": "Emote Autocomplete",
+                        "hint": "Autocomplete emotes when typing with ; prefix",
+                        "value": true
+                    },
+                    {
+                        "id": "emoteactype",
+                        "type": "bool",
+                        "text": "Show most used instead of favourites",
+                        "hint": "Toggle with arrow keys in autocomplete menu",
+                        "value": true
+                    }
+                ]
+            }
+        ]
+    },
+    {
+        "id": "css",
+        "text": "CSS Editor",
+        "settings": [
+            {
+                "id": "default",
+                "settings": [
+                    {
+                        "id": "live-update",
+                        "type": "bool",
+                        "text": "Live update",
+                        "hint": "Automatically recompile custom CSS when typing in the custom CSS editor.",
+                        "value": true
+                    },
+                    {
+                        "id": "watch-files",
+                        "type": "bool",
+                        "text": "Watch included files",
+                        "hint": "Automatically recompile theme and custom CSS when a file it imports is changed.",
+                        "value": true
+                    }
+                ]
+            }
+        ]
     },
     {
         "id": "security",
-        "text": "Security",
+        "text": "Security and Privacy",
+        "headertext": "Security and Privacy Settings",
         "settings": [
-
+            {
+                "id": "default",
+                "settings": [
+                    {
+                        "id": "unsafe-content",
+                        "type": "bool",
+                        "text": "Allow unverified content",
+                        "hint": "Allow loading unverified plugins/themes",
+                        "value": "false"
+                    },
+                    {
+                        "id": "tracking-protection",
+                        "type": "bool",
+                        "text": "Tracking Protection",
+                        "hint": "Disable any Discord tracking",
+                        "value": false
+                    },
+                    {
+                        "id": "e2ee",
+                        "type": "bool",
+                        "text": "E2EE",
+                        "hint": "End-to-end encryption",
+                        "value": false
+                    },
+                    {
+                        "id": "use-keytar",
+                        "type": "bool",
+                        "text": "Use system keychain",
+                        "hint": "Store the master password in the system keychain",
+                        "value": true
+                    }
+                ]
+            },
+            {
+                "id": "e2eedb",
+                "name": "E2EE Database",
+                "type": "drawer",
+                "settings": [
+                    {
+                        "id": "e2ekvps",
+                        "type": ["securekvp"],
+                        "value": []
+                    }
+                ]
+            },
+            {
+                "id": "e2ee-popout",
+                "name": "E2EE Popout",
+                "type": "drawer",
+                "settings": [
+                    {
+                        "id": "position",
+                        "type": "radio",
+                        "text": "Position",
+                        "value": "above",
+                        "fullwidth": true,
+                        "options": [
+                            {
+                                "text": "Above the lock icon",
+                                "value": "above"
+                            },
+                            {
+                                "text": "Over the lock icon",
+                                "value": "over"
+                            }
+                        ]
+                    },
+                    {
+                        "id": "trigger",
+                        "type": "radio",
+                        "text": "Trigger",
+                        "hint": "Only applies when the popout is over the lock icon",
+                        "value": "click",
+                        "fullwidth": true,
+                        "options": [
+                            {
+                                "text": "After clicking the lock icon",
+                                "value": "click"
+                            },
+                            {
+                                "text": "When hovering over the lock icon",
+                                "value": "hover"
+                            }
+                        ]
+                    }
+                ]
+            }
         ]
     }
-]
+]

client/src/dev/serveremu.js

@@ -0,0 +1,232 @@
+const dummyTags = ['dark', 'light', 'simple', 'minimal', 'extra', 'something', 'tag', 'whatever', 'another', 'transparent'];
+
+export default class ServerEmu {
+
+    static async themes(args) {
+        if (!this._themes) this._themes = this.generateThemes();
+
+        await new Promise(r => setTimeout(r, Math.random() * 3000));
+
+        let docs = [];
+
+        if (args && args.sterm) {
+            const { sterm } = args;
+            const reg = new RegExp(sterm, 'gi');
+            docs = this._themes.filter(doc => doc.tags.includes(sterm) || reg.exec(doc.name) || reg.exec(doc.description));
+        } else {
+            docs = this._themes;
+        }
+
+        if (args.sort) {
+            switch (args.sort) {
+            case 'updated':
+                if (args.ascending) docs = docs.sort((docA, docB) => new Date(docA.updated).getTime() - new Date(docB.updated).getTime());
+                else docs = docs.sort((docA, docB) => new Date(docB.updated).getTime() - new Date(docA.updated).getTime());
+                break;
+            case 'installs':
+                if (args.ascending) docs = docs.sort((docA, docB) => docA.installs - docB.installs);
+                else docs = docs.sort((docA, docB) => docB.installs - docA.installs);
+                break;
+            case 'users':
+                if (args.ascending) docs = docs.sort((docA, docB) => docA.activeUsers - docB.activeUsers);
+                else docs = docs.sort((docA, docB) => docB.activeUsers - docA.activeUsers);
+                break;
+            case 'rating':
+                if (args.ascending) docs = docs.sort((docA, docB) => docA.rating - docB.rating);
+                else docs = docs.sort((docA, docB) => docB.rating - docA.rating);
+                break;
+            }
+        }
+
+        const total = docs.length;
+        const pages = Math.ceil(total / 9);
+
+        let page = 1;
+        if (args && args.page) {
+            page = args.page;
+            docs = docs.slice((page - 1) * 9, page * 9);
+        } else {
+            docs = docs.slice(0, 9);
+        }
+
+        return {
+            docs,
+            filters: {
+                sterm: args.sterm || '',
+                ascending: args.ascending || false,
+                sort: args.sort || 'name'
+            },
+            pagination: {
+                total,
+                pages,
+                limit: 9,
+                page
+            }
+        }
+    }
+
+    static async plugins(args) {
+        if (!this._plugins) this._plugins = this.generatePlugins();
+
+        await new Promise(r => setTimeout(r, Math.random() * 3000));
+
+        let docs = [];
+
+        if (args && args.sterm) {
+            const { sterm } = args;
+            const reg = new RegExp(sterm, 'gi');
+            docs = this._plugins.filter(doc => doc.tags.includes(sterm) || reg.exec(doc.name) || reg.exec(doc.description));
+        } else {
+            docs = this._plugins;
+        }
+
+        if (args.sort) {
+            switch (args.sort) {
+            case 'updated':
+                if (args.ascending) docs = docs.sort((docA, docB) => new Date(docA.updated).getTime() - new Date(docB.updated).getTime());
+                else docs = docs.sort((docA, docB) => new Date(docB.updated).getTime() - new Date(docA.updated).getTime());
+                break;
+            case 'installs':
+                if (args.ascending) docs = docs.sort((docA, docB) => docA.installs - docB.installs);
+                else docs = docs.sort((docA, docB) => docB.installs - docA.installs);
+                break;
+            case 'users':
+                if (args.ascending) docs = docs.sort((docA, docB) => docA.activeUsers - docB.activeUsers);
+                else docs = docs.sort((docA, docB) => docB.activeUsers - docA.activeUsers);
+                break;
+            case 'rating':
+                if (args.ascending) docs = docs.sort((docA, docB) => docA.rating - docB.rating);
+                else docs = docs.sort((docA, docB) => docB.rating - docA.rating);
+                break;
+            }
+        }
+
+        const total = docs.length;
+        const pages = Math.ceil(total / 9);
+
+        let page = 1;
+        if (args && args.page) {
+            page = args.page;
+            docs = docs.slice((page - 1) * 9, page * 9);
+        } else {
+            docs = docs.slice(0, 9);
+        }
+
+        return {
+            docs,
+            filters: {
+                sterm: args.sterm || '',
+                ascending: args.ascending || false,
+                sort: args.sort || 'name'
+            },
+            pagination: {
+                total,
+                pages,
+                limit: 9,
+                page
+            }
+        }
+    }
+
+    static generateThemes() {
+        const docs = [];
+        const count = Math.floor(Math.random() * 50 + 30);
+
+        for (let i = 0; i < count; i++) {
+            const id = `theme${i}-${this.randomId()}`;
+            const name = `Dummy Theme ${i}`;
+            const tags = dummyTags.sort(() => .5 - Math.random()).slice(0, 3);
+
+            docs.push({
+                id,
+                name,
+                tags,
+                installs: Math.floor(Math.random() * 5000) + 5000,
+                updated: this.randomTimestamp(),
+                rating: Math.floor(Math.random() * 500) + 500,
+                activeUsers: Math.floor(Math.random() * 1000) + 1000,
+                rated: Math.random() > .5,
+                version: this.randomVersion(),
+                repository: this.dummyThemeRepo,
+                files: this.dummyFiles,
+                author: this.dummyAuthor,
+                description: ''
+            });
+        }
+
+        return docs;
+    }
+
+    static generatePlugins() {
+        const docs = [];
+        const count = Math.floor(Math.random() * 50 + 30);
+
+        for (let i = 0; i < count; i++) {
+            const id = `plugin${i}-${this.randomId()}`;
+            const name = `Dummy Plugin ${i}`;
+            const tags = dummyTags.sort(() => .5 - Math.random()).slice(0, 3);
+
+            docs.push({
+                id,
+                name,
+                tags,
+                installs: Math.floor(Math.random() * 5000) + 5000,
+                updated: this.randomTimestamp(),
+                rating: Math.floor(Math.random() * 500) + 500,
+                activeUsers: Math.floor(Math.random() * 1000) + 1000,
+                rated: Math.random() > .5,
+                version: this.randomVersion(),
+                repository: this.dummyPluginRepo,
+                files: this.dummyFiles,
+                author: this.dummyAuthor,
+                description: ''
+            });
+        }
+
+        return docs;
+    }
+
+    static get dummyThemeRepo() {
+        return {
+            name: 'ExampleRepository',
+            baseUri: 'https://github.com/Jiiks/ExampleRepository',
+            rawUri: 'https://github.com/Jiiks/ExampleRepository/raw/master',
+            assetUri: 'https://api.github.com/repos/Jiiks/ExampleRepository/releases/assets/10023264'
+        }
+    }
+
+    static get dummyPluginRepo() {
+        return {
+            name: 'ExampleRepository',
+            baseUri: 'https://github.com/Jiiks/ExampleRepository',
+            rawUri: 'https://github.com/Jiiks/ExampleRepository/raw/master',
+            assetUri: 'https://api.github.com/repos/Jiiks/ExampleRepository/releases/assets/10023265'
+        }
+    }
+
+    static get dummyFiles() {
+        return {
+            readme: 'Example/readme.md',
+            previews: [{
+                large: 'Example/preview1-big.png',
+                thumb: 'Example/preview1-small.png'
+            }]
+        }
+    }
+
+    static get dummyAuthor() {
+        return 'Someone';
+    }
+
+    static randomId() {
+        return btoa(Math.random()).substring(3, 9);
+    }
+
+    static randomTimestamp() {
+        return `2018-${Math.floor((Math.random() * 12) + 1).toString().padStart(2, '0')}-${Math.floor((Math.random() * 30) + 1).toString().padStart(2, '0')}T14:51:32.057Z`;
+    }
+
+    static randomVersion() {
+        return `${Math.round(Math.random() * 3)}.${Math.round(Math.random() * 10)}.${Math.round(Math.random() * 10)}`;
+    }
+}

client/src/index.js

@@ -8,41 +8,134 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-import { DOM, BdUI } from 'ui';
+import { DOM, BdUI, BdMenu, Modals, Toasts, Notifications, BdContextMenu, DiscordContextMenu, Autocomplete } from 'ui';
 import BdCss from './styles/index.scss';
-import { Events, CssEditor, Globals, PluginManager, ThemeManager, ModuleManager, WebpackModules } from 'modules';
-import { ClientLogger as Logger } from 'common';
+import { Events, Globals, Settings, Database, Updater, ModuleManager, PluginManager, ThemeManager, ExtModuleManager, Vendor, Patcher, MonkeyPatch, ReactComponents, ReactHelpers, ReactAutoPatcher, DiscordApi, BdWebApi, Connectivity, Cache, Reflection, PackageInstaller } from 'modules';
+import { ClientLogger as Logger, ClientIPC, Utils, Axi } from 'common';
+import { BuiltinManager, EmoteModule, ReactDevtoolsModule, VueDevtoolsModule, TrackingProtection, E2EE } from 'builtin';
+import electron from 'electron';
+import path from 'path';
+
+const tests = typeof PRODUCTION === 'undefined';
+const ignoreExternal = tests && true;
 
 class BetterDiscord {
 
     constructor() {
-        window.css = CssEditor;
-        window.pm = PluginManager;
-        window.events = Events;
-        window.wpm = WebpackModules;
-        DOM.injectStyle(BdCss, 'bdmain');
-        Events.on('global-ready', this.globalReady.bind(this));
-    }
+        Logger.file = tests ? path.resolve(__dirname, '..', '..', 'tests', 'log.txt') : path.join(__dirname, 'log.txt');
+        Logger.trimLogFile();
+        Logger.log('main', 'BetterDiscord starting');
 
-    async init() {
-        await ModuleManager.initModules();
-        await PluginManager.loadAllPlugins();
-        await ThemeManager.loadAllThemes();
-        Events.emit('ready');
-        Events.emit('discord-ready');
+        this._bd = {
+            DOM, BdUI, BdMenu, Modals, Reflection, Toasts, Notifications, BdContextMenu, DiscordContextMenu, Autocomplete,
+
+            Events, Globals, Settings, Database, Updater,
+            ModuleManager, PluginManager, ThemeManager, ExtModuleManager, PackageInstaller,
+            Vendor,
+
+            Patcher, MonkeyPatch, ReactComponents, ReactHelpers, ReactAutoPatcher, DiscordApi,
+            BuiltinManager, EmoteModule,
+            BdWebApi,
+            Connectivity,
+            Cache,
+            Logger, ClientIPC, Utils, Axi,
+
+            plugins: PluginManager.localContent,
+            themes: ThemeManager.localContent,
+            extmodules: ExtModuleManager.localContent,
+
+            __filename, __dirname,
+            module: Globals.require.cache[__filename],
+            require: Globals.require,
+            webpack_require: __webpack_require__, // eslint-disable-line no-undef
+            get discord_require() { return Reflection.require }
+        };
+
+        const developermode = Settings.getSetting('core', 'advanced', 'developer-mode');
+        if (developermode.value) window._bd = this._bd;
+        developermode.on('setting-updated', event => {
+            if (event.value) window._bd = this._bd;
+            else if (window._bd) delete window._bd;
+        });
+
+        const debuggerkeybind = Settings.getSetting('core', 'advanced', 'debugger-keybind');
+        debuggerkeybind.on('keybind-activated', () => {
+            const currentWindow = electron.remote.getCurrentWindow();
+            if (currentWindow.isDevToolsOpened()) return eval('debugger;');
+            currentWindow.openDevTools();
+            setTimeout(() => eval('debugger;'), 1000);
+        });
+
+        DOM.injectStyle(BdCss, 'bdmain');
+        this.globalReady = this.globalReady.bind(this);
+        Events.on('global-ready', this.globalReady);
+        Globals.initg();
     }
 
     globalReady() {
         BdUI.initUiEvents();
         this.vueInstance = BdUI.injectUi();
-        (async () => {
-            this.init();
-        })();
+        this.init();
     }
+
+    async init() {
+        try {
+            await Database.init();
+            await Settings.loadSettings();
+            await ModuleManager.initModules();
+            BuiltinManager.initAll();
+
+            if (tests) this.initTests();
+
+            if (!ignoreExternal) {
+                await ExtModuleManager.loadAllModules(true);
+                await PluginManager.loadAllPlugins(true);
+                await ThemeManager.loadAllThemes(true);
+            }
+
+            Events.emit('ready');
+            Events.emit('discord-ready');
+
+            if (!Settings.get('core', 'advanced', 'ignore-content-manager-errors'))
+                Modals.showContentManagerErrors();
+        } catch (err) {
+            Logger.err('main', ['FAILED TO LOAD!', err]);
+        }
+    }
+
+    initTests() {
+        let notifications = 0;
+        function showDummyNotif() { // eslint-disable-line no-inner-declarations
+            Notifications.add(notifications++ ? `Notification ${notifications}` : undefined, 'Dummy Notification', [
+                {
+                    text: 'Show Again', onClick: function () {
+                        setTimeout(showDummyNotif, 5000);
+                        return true;
+                    }
+                },
+                {
+                    text: 'Ignore', onClick: function () {
+                        return true;
+                    }
+                }
+            ]);
+        }
+        showDummyNotif();
+
+        DiscordContextMenu.add([
+            {
+                text: 'Hello',
+                onClick: () => { Toasts.info('Hello!'); }
+            }
+        ]);
+    }
+
 }
 
 if (window.BetterDiscord) {
     Logger.log('main', 'Attempting to inject again?');
 } else {
-    let bdInstance = new BetterDiscord();
+    let instance;
+    Events.on('autopatcher', () => instance = new BetterDiscord());
+    ReactAutoPatcher.autoPatch().then(() => Events.emit('autopatcher'));
 }

client/src/modules/bdwebapi.js

@@ -0,0 +1,82 @@
+/**
+ * BetterDiscord Web Apis
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import ServerEmu from '../dev/serveremu';
+
+import { request } from 'vendor';
+
+const APIBASE = 'ifyouareinwebtestthenyouknowwhatthisshouldbe'; // Do not push
+const ENDPOINTS = {
+    'themes': `${APIBASE}/themes`,
+    'theme': id => `${APIBASE}/theme/${id}`,
+    'users': `${APIBASE}/users`,
+    'user': id => `${APIBASE}/user/${id}`,
+    'statistics': `${APIBASE}/statistics`
+};
+
+export default class BdWebApi {
+
+    static get themes() {
+        return {
+            get: this.getThemes
+        };
+    }
+
+    static get plugins() {
+        return {
+            get: this.getPlugins
+        };
+    }
+
+    static get users() {
+        return {
+            get: this.getUsers
+        };
+    }
+
+    static get statistics() {
+        return {
+            get: this.getStatistics,
+            patch: this.patchStatistics
+        };
+    }
+
+    static getThemes(args) {
+        return ServerEmu.themes(args);
+        //  return dummyThemes();
+        /*
+        if (!args) return request.get(ENDPOINTS.themes);
+        const { id } = args;
+        if (id) return request.get(ENDPOINTS.theme(id));
+
+        return request.get(ENDPOINTS.themes);
+        */
+    }
+
+    static getPlugins(args) {
+        return ServerEmu.plugins(args);
+    }
+
+    static getUsers(args) {
+        if (!args) return request.get(ENDPOINTS.users);
+        const { id } = args;
+        if (id) return request.get(ENDPOINTS.user(id));
+
+        return request.get(ENDPOINTS.users);
+    }
+
+    static getStatistics() {
+        return request.get(ENDPOINTS.statistics);
+    }
+
+    static patchStatistics(json) {
+        return request({ method: 'PATCH', url: ENDPOINTS.statistics, json });
+    }
+}

client/src/modules/cache.js

@@ -0,0 +1,38 @@
+/**
+ * BetterDiscord Cache Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+const CACHE = [];
+
+export default class Cache {
+
+    static get cache() {
+        return CACHE;
+    }
+
+    /**
+     * Push something to cache
+     * @param {String} where Cache identifier
+     * @param {any} data Data to push
+     */
+    static push(where, data) {
+        if (!this.cache[where]) this.cache[where] = [];
+        this.cache[where].push(data);
+    }
+
+    /**
+     * Find something in cache
+     * @param {String} where Cache identifier
+     * @param {Function} what Find callback
+     */
+    static find(where, what) {
+        if (!this.cache[where]) this.cache[where] = [];
+        return this.cache[where].find(what);
+    }
+
+}

client/src/modules/connectivity.js

@@ -0,0 +1,25 @@
+/**
+ * BetterDiscord Connectivity Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import BdWebApi from './bdwebapi';
+import { ClientLogger as Logger } from 'common';
+
+export default class Connectivity {
+
+    static start() {
+        Logger.info('Connectivity', `Patching anonymous statistics`);
+        BdWebApi.statistics.patch({ themes: [], plugins: [] });
+        setInterval(() => {
+            Logger.info('Connectivity', `Patching anonymous statistics`);
+            BdWebApi.statistics.patch({ themes: [], plugins: [] });
+        }, 15*60*1000);
+    }
+
+}

client/src/modules/content.js

@@ -0,0 +1,149 @@
+/**
+ * BetterDiscord Content Base
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Utils, ClientLogger as Logger, AsyncEventEmitter } from 'common';
+import { Modals } from 'ui';
+import Database from './database';
+
+export default class Content extends AsyncEventEmitter {
+
+    constructor(internals) {
+        super();
+
+        internals.loaded = Date.now();
+        internals.started = undefined;
+        internals.stopped = undefined;
+
+        Utils.deepfreeze(internals.info);
+        Object.freeze(internals.paths);
+
+        this.__internals = internals;
+
+        this.settings.on('setting-updated', event => this.emit('setting-updated', event));
+        this.settings.on('settings-updated', event => this.emit('settings-updated', event));
+        this.settings.on('settings-updated', event => this.__settingsUpdated(event));
+
+        // Add hooks
+        if (this.onstart) this.on('start', event => this.onstart(event));
+        if (this.onStart) this.on('start', event => this.onStart(event));
+        if (this.onstop) this.on('stop', event => this.onstop(event));
+        if (this.onStop) this.on('stop', event => this.onStop(event));
+        if (this.onunload) this.on('unload', event => this.onunload(event));
+        if (this.onUnload) this.on('unload', event => this.onUnload(event));
+        if (this.settingUpdated) this.on('setting-updated', event => this.settingUpdated(event));
+        if (this.settingsUpdated) this.on('settings-updated', event => this.settingsUpdated(event));
+    }
+
+    get type() { return undefined }
+    get configs() { return this.__internals.configs }
+    get info() { return this.__internals.info }
+    get paths() { return this.__internals.paths }
+    get main() { return this.__internals.main }
+    get defaultConfig() { return this.configs.defaultConfig }
+    get userConfig() { return this.configs.userConfig }
+    get configSchemes() { return this.configs.schemes }
+    get id() { return this.info.id || this.name.toLowerCase().replace(/[^a-zA-Z0-9-]/g, '-').replace(/--/g, '-') }
+    get name() { return this.info.name }
+    get icon() { return this.info.icon }
+    get description() { return this.info.description }
+    get authors() { return this.info.authors }
+    get version() { return this.info.version }
+    get loadedTimestamp() { return this.__internals.loaded }
+    get startedTimestamp() { return this.__internals.started }
+    get stoppedTimestamp() { return this.__internals.stopped }
+    get contentPath() { return this.paths.contentPath }
+    get dirName() { return this.paths.dirName }
+    get enabled() { return this.userConfig.enabled }
+    get settings() { return this.userConfig.config }
+    get config() { return this.settings.categories }
+    get data() { return this.userConfig.data || (this.userConfig.data = {}) }
+
+    get packed() { return this.dirName.packed }
+    get packagePath() { return this.dirName.packagePath }
+    get packageName() { return this.dirName.pkg }
+
+    /**
+     * Opens a settings modal for this content.
+     * @return {Modal}
+     */
+    showSettingsModal() {
+        return Modals.contentSettings(this);
+    }
+
+    /**
+     * Whether this content has any settings.
+     */
+    get hasSettings() {
+        return !!this.settings.findSetting(() => true);
+    }
+
+    /**
+     * Saves the content's current configuration.
+     * @return {Promise}
+     */
+    async saveConfiguration() {
+        try {
+            Database.insertOrUpdate({ type: `${this.type}-config`, id: this.id }, {
+                type: `${this.type}-config`,
+                id: this.id,
+                enabled: this.enabled,
+                config: this.settings.strip().settings,
+                data: this.data
+            });
+            this.settings.setSaved();
+        } catch (err) {
+            Logger.err(this.name, ['Failed to save configuration', err]);
+            throw err;
+        }
+    }
+
+    /**
+     * Called when settings are updated.
+     * This can be overridden by other content types.
+     */
+    __settingsUpdated(event) {
+        return this.saveConfiguration();
+    }
+
+    /**
+     * Enables the content.
+     * @param {Boolean} save Whether to save the new enabled state
+     * @return {Promise}
+     */
+    async enable(save = true) {
+        if (this.enabled) return;
+        await this.emit('enable');
+        await this.emit('start');
+
+        this.__internals.started = Date.now();
+        this.__internals.stopped = undefined;
+        this.userConfig.enabled = true;
+        if (save) await this.saveConfiguration();
+    }
+
+    /**
+     * Disables the content.
+     * @param {Boolean} save Whether to save the new enabled state
+     * @return {Promise}
+     */
+    async disable(save = true) {
+        if (!this.enabled) return;
+        await this.emit('stop');
+        await this.emit('disable');
+
+        this.__internals.started = undefined;
+        this.__internals.stopped = Date.now();
+        this.userConfig.enabled = false;
+        if (save) await this.saveConfiguration();
+    }
+
+}
+
+Object.freeze(Content.prototype);

client/src/modules/contentmanager.js

@@ -8,183 +8,442 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-import Globals from './globals';
-import { FileUtils, ClientLogger as Logger } from 'common';
-import path from 'path';
-import { Events } from 'modules';
-import { Error } from 'structs';
+import asar from 'asar';
+import path, { dirname } from 'path';
+import rimraf from 'rimraf';
 
+import { remote } from 'electron';
+import Content from './content';
+import Globals from './globals';
+import Database from './database';
+import { Utils, FileUtils, ClientLogger as Logger } from 'common';
+import { SettingsSet, ErrorEvent } from 'structs';
+import { Modals } from 'ui';
+import Combokeys from 'combokeys';
+import Settings from './settings';
+
+/**
+ * Base class for managing external content
+ */
 export default class {
 
+    /**
+     * Any errors that happened.
+     * @return {Array}
+     */
     static get errors() {
         return this._errors || (this._errors = []);
     }
 
+    /**
+     * Locally stored content.
+     * @return {Array}
+     */
     static get localContent() {
         return this._localContent ? this._localContent : (this._localContent = []);
     }
 
-    static get contentPath() {
-        return this._contentPath ? this._contentPath : (this._contentPath = Globals.getObject('paths').find(path => path.id === this.pathId).path);
+    /**
+     * The type of content this content manager manages.
+     */
+    static get contentType() {
+        return undefined;
     }
 
-    static async loadAllContent() {
+    /**
+     * The name of this content manager.
+     */
+    static get moduleName() {
+        return undefined;
+    }
+
+    /**
+     * The path used to store this content manager's content.
+     */
+    static get pathId() {
+        return undefined;
+    }
+
+    /**
+     * Local path for content.
+     * @return {String}
+     */
+    static get contentPath() {
+        return Globals.getPath(this.pathId);
+    }
+
+    static async packContent(path, contentPath) {
+        return new Promise((resolve, reject) => {
+            remote.dialog.showSaveDialog({
+                title: 'Save Package',
+                defaultPath: path,
+                filters: [
+                    {
+                        name: 'BetterDiscord Package',
+                        extensions: ['bd']
+                    }
+                ]
+            }, filepath => {
+                if (!filepath) return;
+
+                asar.uncache(filepath);
+                asar.createPackage(contentPath, filepath, () => {
+                    resolve(filepath);
+                });
+            });
+        });
+    }
+
+    /**
+     * Load all locally stored content.
+     * @param {bool} suppressErrors Suppress any errors that occur during loading of content
+     */
+    static async loadAllContent(suppressErrors = false) {
         try {
             await FileUtils.ensureDirectory(this.contentPath);
             const directories = await FileUtils.listDirectory(this.contentPath);
 
-            for (let dir of directories) {
+            for (const dir of directories) {
+                const packed = dir.endsWith('.bd');
+
+                if (!packed) {
+                    try {
+                        await FileUtils.directoryExists(path.join(this.contentPath, dir));
+                    } catch (err) { continue; }
+                }
+
                 try {
-                    await this.preloadContent(dir);
+                    if (packed) {
+                        await this.preloadPackedContent(dir);
+                    } else {
+                        await this.preloadContent(dir);
+                    }
                 } catch (err) {
-                    this.errors.push(new Error({
+                    this.errors.push(new ErrorEvent({
                         module: this.moduleName,
                         message: `Failed to load ${dir}`,
                         err
                     }));
-                    
+
                     Logger.err(this.moduleName, err);
                 }
             }
 
-            if (this.errors.length) {
-                Events.emit('bd-error', {
-                    header: `${this.moduleName} - one or more ${this.contentType}(s) failed to load`,
+            if (this.errors.length && !suppressErrors) {
+                Modals.error({
+                    header: `${this.moduleName} - ${this.errors.length} ${this.contentType}${this.errors.length !== 1 ? 's' : ''} failed to load`,
                     module: this.moduleName,
                     type: 'err',
                     content: this.errors
                 });
+                this._errors = [];
             }
-            this._errors = [];
-
-            return this.localContent;
         } catch (err) {
             throw err;
         }
     }
 
-    static async refreshContent() {
+    /**
+     * Refresh locally stored content
+     * @param {bool} suppressErrors Suppress any errors that occur during loading of content
+     */
+    static async refreshContent(suppressErrors = false) {
         if (!this.localContent.length) return this.loadAllContent();
 
         try {
             await FileUtils.ensureDirectory(this.contentPath);
             const directories = await FileUtils.listDirectory(this.contentPath);
 
-            for (let dir of directories) {
-                // If content is already loaded this should resolve.
+            for (const dir of directories) {
+                const packed = dir.endsWith('.bd');
+
+                // If content is already loaded this should resolve
                 if (this.getContentByDirName(dir)) continue;
 
+                try {
+                    await FileUtils.directoryExists(path.join(this.contentPath, dir));
+                } catch (err) { continue; }
+
                 try {
                     // Load if not
                     await this.preloadContent(dir);
                 } catch (err) {
-                    //We don't want every plugin/theme to fail loading when one does
+                    // We don't want every plugin/theme to fail loading when one does
+                    this.errors.push(new ErrorEvent({
+                        module: this.moduleName,
+                        message: `Failed to load ${dir}`,
+                        err
+                    }));
+
                     Logger.err(this.moduleName, err);
                 }
             }
 
-            for (let content of this.localContent) {
+            for (const content of this.localContent) {
                 if (directories.includes(content.dirName)) continue;
-                //Plugin/theme was deleted manually, stop it and remove any reference
-                this.unloadContent(content);
+
+                try {
+                    // Plugin/theme was deleted manually, stop it and remove any reference
+                    await this.unloadContent(content);
+                } catch (err) {
+                    this.errors.push(new ErrorEvent({
+                        module: this.moduleName,
+                        message: `Failed to unload ${content.dirName}`,
+                        err
+                    }));
+
+                    Logger.err(this.moduleName, err);
+                }
             }
 
-            return this.localContent;
-
+            if (this.errors.length && !suppressErrors) {
+                Modals.error({
+                    header: `${this.moduleName} - ${this.errors.length} ${this.contentType}${this.errors.length !== 1 ? 's' : ''} failed to load`,
+                    module: this.moduleName,
+                    type: 'err',
+                    content: this.errors
+                });
+                this._errors = [];
+            }
         } catch (err) {
             throw err;
         }
     }
 
+    static async preloadPackedContent(pkg, reload = false, index) {
+        try {
+            const packagePath = path.join(this.contentPath, pkg);
+            const packageName = pkg.replace('.bd', '');
+            await FileUtils.fileExists(packagePath);
+
+            const config = JSON.parse(asar.extractFile(packagePath, 'config.json').toString());
+            const unpackedPath = path.join(Globals.getPath('tmp'), packageName);
+
+            asar.extractAll(packagePath, unpackedPath);
+
+            return this.preloadContent({
+                config,
+                contentPath: unpackedPath,
+                packagePath: packagePath,
+                pkg,
+                packageName,
+                packed: true
+            }, reload, index);
+        } catch (err) {
+            Logger.log('ContentManager', ['Error extracting packed content', err]);
+            throw err;
+        }
+    }
+
+    /**
+     * Common loading procedure for loading content before passing it to the actual loader
+     * @param {any} dirName Base directory for content
+     * @param {any} reload Is content being reloaded
+     * @param {any} index Index of content in {localContent}
+     */
     static async preloadContent(dirName, reload = false, index) {
         try {
-            const contentPath = path.join(this.contentPath, dirName);
+            const unsafeAllowed = Settings.getSetting('security', 'default', 'unsafe-content').value;
+            const packed = typeof dirName === 'object' && dirName.packed;
+
+            // Block any unpacked content as they can't be verified
+            if (!packed && !unsafeAllowed) {
+                throw 'Blocked unsafe content';
+            }
+
+            const contentPath = packed ? dirName.contentPath : path.join(this.contentPath, dirName);
 
             await FileUtils.directoryExists(contentPath);
 
-            if (!reload) {
-                const loaded = this.localContent.find(content => content.contentPath === contentPath);
-                if (loaded) {
-                    throw { 'message': `Attempted to load already loaded user content: ${path}` };
-                }
-            }
+            if (!reload && this.getContentByPath(contentPath))
+                throw { 'message': `Attempted to load already loaded user content: ${path}` };
 
-            const readConfig = await this.readConfig(contentPath);
-            const mainPath = path.join(contentPath, readConfig.main);
+            const configPath = path.resolve(contentPath, 'config.json');
+            const readConfig = packed ? dirName.config : await FileUtils.readJsonFromFile(configPath);
+            const mainPath = path.join(contentPath, readConfig.main || 'index.js');
+
+            const defaultConfig = new SettingsSet({
+                settings: readConfig.defaultConfig,
+                schemes: readConfig.configSchemes
+            });
 
             const userConfig = {
                 enabled: false,
-                config: readConfig.defaultConfig
+                config: undefined,
+                data: {}
             };
 
             try {
-                const readUserConfig = await this.readUserConfig(contentPath);
-                userConfig.enabled = readUserConfig.enabled || false;
-                userConfig.config = readConfig.defaultConfig.map(config => {
-                    const userSet = readUserConfig.config.find(c => c.category === config.category);
-                    // return userSet || config;
-                    if (!userSet) return config;
-
-                    config.settings = config.settings.map(setting => {
-                        const userSetting = userSet.settings.find(s => s.id === setting.id);
-                        if (!userSetting) return setting;
-
-                        setting.value = userSetting.value;
-                        return setting;
-                    });
-                    return config;
-                });
-                // userConfig.config = readUserConfig.config;
-            } catch (err) { /*We don't care if this fails it either means that user config doesn't exist or there's something wrong with it so we revert to default config*/
-
+                const id = readConfig.info.id || readConfig.info.name.toLowerCase().replace(/[^a-zA-Z0-9-]/g, '-').replace(/--/g, '-');
+                const readUserConfig = await Database.find({ type: `${this.contentType}-config`, id });
+                if (readUserConfig.length) {
+                    userConfig.enabled = readUserConfig[0].enabled || false;
+                    userConfig.config = readUserConfig[0].config;
+                    userConfig.data = readUserConfig[0].data || {};
+                }
+            } catch (err) {
+                // We don't care if this fails it either means that user config doesn't exist or there's something wrong with it so we revert to default config
+                Logger.warn(this.moduleName, [`Failed reading config for ${this.contentType} ${readConfig.info.name} in ${packed ? dirName.pkg : dirName}`, err]);
             }
 
+            userConfig.config = defaultConfig.clone({ settings: userConfig.config });
+            userConfig.config.setSaved();
+
+            for (const setting of userConfig.config.findSettings(() => true)) {
+                // This will load custom settings
+                // Setting the content's path on only the live config (and not the default config) ensures that custom settings will not be loaded on the default settings
+                setting.setContentPath(contentPath);
+            }
+
+            for (const scheme of userConfig.config.schemes) {
+                scheme.setContentPath(contentPath);
+            }
+
+            Utils.deepfreeze(defaultConfig, object => object instanceof Combokeys);
+
             const configs = {
-                defaultConfig: readConfig.defaultConfig,
+                defaultConfig,
+                schemes: userConfig.schemes,
                 userConfig
-            }
+            };
 
             const paths = {
                 contentPath,
                 dirName,
                 mainPath
-            }
+            };
 
-            const content = await this.loadContent(paths, configs, readConfig.info, readConfig.main);
-            if (reload) this.localContent[index] = content;
+            const content = await this.loadContent(paths, configs, readConfig.info, readConfig.main, readConfig.dependencies, readConfig.permissions, readConfig.mainExport, packed ? dirName : false);
+            if (!content) return undefined;
+            if (!reload && this.getContentById(content.id))
+                throw { message: `A ${this.contentType} with the ID ${content.id} already exists.` };
+
+            if (reload) this.localContent.splice(index, 1, content);
             else this.localContent.push(content);
             return content;
-
         } catch (err) {
             throw err;
         }
     }
 
-    static async readConfig(configPath) {
-        configPath = path.resolve(configPath, 'config.json');
-        return FileUtils.readJsonFromFile(configPath);
+    /**
+     * Delete content.
+     * @param {Content|String} content Content to delete
+     * @param {Boolean} force If true the content will be deleted even if an exception is thrown when disabling/unloading/deleting
+     */
+    static async deleteContent(content, force) {
+        content = this.findContent(content);
+        if (!content) throw {message: `Could not find a ${this.contentType} from ${content}.`};
+
+        try {
+            await Modals.confirm(`Delete ${this.contentType}?`, `Are you sure you want to delete ${content.info.name} ?`, 'Delete').promise;
+        } catch (err) {
+            return false;
+        }
+
+        try {
+            const unload = this.unloadContent(content, force, false);
+
+            if (!force)
+                await unload;
+
+            await FileUtils.recursiveDeleteDirectory(content.paths.contentPath);
+            if (content.packed) await FileUtils.recursiveDeleteDirectory(content.packagePath);
+            return true;
+        } catch (err) {
+            Logger.err(this.moduleName, err);
+            throw err;
+        }
     }
 
-    static async readUserConfig(configPath) {
-        configPath = path.resolve(configPath, 'user.config.json');
-        return FileUtils.readJsonFromFile(configPath);
+    /**
+     * Unload content.
+     * @param {Content|String} content Content to unload
+     * @param {Boolean} force If true the content will be unloaded even if an exception is thrown when disabling/unloading
+     * @param {Boolean} reload Whether to reload the content after
+     * @return {Content}
+     */
+    static async unloadContent(content, force, reload) {
+        content = this.findContent(content);
+        if (!content) throw {message: `Could not find a ${this.contentType} from ${content}.`};
+
+        try {
+            const disablePromise = content.disable(false);
+            const unloadPromise = content.emit('unload', reload);
+
+            if (!force) {
+                await disablePromise;
+                await unloadPromise;
+            }
+
+            const index = this.getContentIndex(content);
+
+            if (this.unloadContentHook) this.unloadContentHook(content);
+
+            if (reload) return content.packed ? this.preloadPackedContent(content.packagePath, true, index) : this.preloadContent(content.dirName, true, index);
+
+            this.localContent.splice(index, 1);
+        } catch (err) {
+            Logger.err(this.moduleName, err);
+            throw err;
+        }
     }
 
-    //TODO make this nicer
-    static findContent(wild) {
-        let content = this.getContentByName(wild);
-        if (content) return content;
-        content = this.getContentById(wild);
-        if (content) return content;
-        content = this.getContentByPath(wild);
-        if (content) return content;
-        return this.getContentByDirName(wild);
+    /**
+     * Reload content.
+     * @param {Content|String} content Content to reload
+     * @param {Boolean} force If true the content will be unloaded even if an exception is thrown when disabling/unloading
+     * @return {Content}
+     */
+    static reloadContent(content, force) {
+        return this.unloadContent(content, force, true);
+    }
+
+    /**
+     * Checks if the passed object is an instance of this content type.
+     * @param {Any} content Object to check
+     * @return {Boolean}
+     */
+    static isThisContent(content) {
+        return content instanceof Content;
+    }
+
+    /**
+     * Returns the first content where calling {function} returns true.
+     * @param {Function} function A function to call to filter content
+     */
+    static find(f) {
+        return this.localContent.find(f);
+    }
+
+    /**
+     * Wildcard content finder
+     * @param {String} wild Content ID / directory name / path / name
+     * @param {Boolean} nonunique Allow searching attributes that may not be unique
+     * @return {Content}
+     */
+    static findContent(wild, nonunique) {
+        if (this.isThisContent(wild)) return wild;
+        let content;
+        content = this.getContentById(wild); if (content) return content;
+        content = this.getContentByDirName(wild); if (content) return content;
+        content = this.getContentByPath(wild); if (content) return content;
+        content = this.getContentByName(wild); if (content && nonunique) return content;
     }
 
     static getContentIndex(content) { return this.localContent.findIndex(c => c === content) }
-    static getContentByName(name) { return this.localContent.find(c => c.name === name) }
     static getContentById(id) { return this.localContent.find(c => c.id === id) }
-    static getContentByPath(path) { return this.localContent.find(c => c.contentPath === path) }
     static getContentByDirName(dirName) { return this.localContent.find(c => c.dirName === dirName) }
+    static getContentByPath(path) { return this.localContent.find(c => c.contentPath === path) }
+    static getContentByName(name) { return this.localContent.find(c => c.name === name) }
+
+    /**
+     * Wait for content to load
+     * @param {String} content_id
+     * @return {Promise => Content}
+     */
+    static waitForContent(content_id) {
+        return Utils.until(() => this.getContentById(content_id), 100);
+    }
 
 }

client/src/modules/csseditor.js

@@ -8,19 +8,311 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-import { ClientIPC } from 'common';
 import { DOM } from 'ui';
+import { FileUtils, ClientLogger as Logger, ClientIPC } from 'common';
+import path from 'path';
+import electron from 'electron';
+import filewatcher from 'filewatcher';
+import Settings from './settings';
 
-export default class {
+/**
+ * Custom css editor communications
+ */
+export default new class {
 
-    static async show() {
-        const t = await ClientIPC.send('openCssEditor', {});
-        ClientIPC.send('setCss', { css: DOM.getStyleCss('bd-customcss') });
-
-        ClientIPC.on('bd-update-css', this.updateCss);
+    constructor() {
+        this._scss = '';
+        this._css = '';
+        this._error = undefined;
+        this.editor_bounds = undefined;
+        this._files = undefined;
+        this._filewatcher = undefined;
+        this._watchfiles = undefined;
+        this.compiling = false;
     }
 
-    static updateCss(e, css) {
+    /**
+     * Init css editor.
+     */
+    init() {
+        ClientIPC.on('bd-get-scss', () => this.scss, true);
+        ClientIPC.on('bd-update-scss', (e, scss) => this.updateScss(scss));
+        ClientIPC.on('bd-save-csseditor-bounds', (e, bounds) => this.saveEditorBounds(bounds));
+        ClientIPC.on('bd-editor-runScript', (e, script) => {
+            try {
+                new Function(script)();
+                e.reply('ok');
+            } catch (err) {
+                e.reply({ err: err.stack || err });
+            }
+        });
+
+        ClientIPC.on('bd-save-scss', async (e, scss) => {
+            await this.updateScss(scss);
+            await this.save();
+        }, true);
+
+        this.liveupdate = Settings.getSetting('css', 'default', 'live-update');
+        this.liveupdate.on('setting-updated', event => {
+            this.sendToEditor('set-liveupdate', event.value);
+        });
+
+        ClientIPC.on('bd-get-liveupdate', () => this.liveupdate.value, true);
+        ClientIPC.on('bd-set-liveupdate', (e, value) => this.liveupdate.value = value);
+
+        this.watchfilessetting = Settings.getSetting('css', 'default', 'watch-files');
+        this.watchfilessetting.on('setting-updated', event => {
+            if (event.value) this.watchfiles = this.files;
+            else this.watchfiles = [];
+        });
+    }
+
+    /**
+     * Show css editor, flashes if already visible.
+     */
+    async show() {
+        await ClientIPC.send('openCssEditor', this.editor_bounds);
+    }
+
+    /**
+     * Update css in client.
+     * @param {String} scss SCSS to compile
+     * @param {bool} sendSource Whether to send to css editor instance
+     */
+    async updateScss(scss, sendSource) {
+        if (sendSource)
+            this.sendToEditor('set-scss', scss);
+
+        if (!scss && !await this.fileExists()) {
+            this._scss = this.css = '';
+            this.sendToEditor('scss-error', null);
+            return;
+        }
+
+        try {
+            this.compiling = true;
+            const result = await this.compile(scss);
+            this.css = result.css.toString();
+            this._scss = scss;
+            this.files = result.stats.includedFiles;
+            this.error = null;
+            this.compiling = false;
+        } catch (err) {
+            this.compiling = false;
+            this.error = err;
+            throw err;
+        }
+    }
+
+    /**
+     * Save css to file.
+     * @return {Promise}
+     */
+    save() {
+        return Settings.saveSettings();
+    }
+
+    /**
+     * Save current editor bounds.
+     * @param {Rectangle} bounds Editor bounds
+     * @return {Promise}
+     */
+    saveEditorBounds(bounds) {
+        this.editor_bounds = bounds;
+        return Settings.saveSettings();
+    }
+
+    /**
+     * Send SCSS to core for compilation.
+     * @param {String} scss SCSS string
+     */
+    async compile(scss) {
+        return ClientIPC.send('bd-compileSass', {
+            data: scss,
+            path: await this.fileExists() ? this.filePath : undefined
+        });
+    }
+
+    /**
+     * Recompile the current SCSS.
+     * @return {Promise}
+     */
+    async recompile() {
+        return this.updateScss(this.scss);
+    }
+
+    /**
+     * Send data to open editor.
+     * @param {String} channel
+     * @param {Any} data
+     * @return {Promise}
+     */
+    async sendToEditor(channel, data) {
+        return ClientIPC.sendToCssEditor(channel, data);
+    }
+
+    /**
+     * Opens an SCSS file in a system editor.
+     * @return {Promise}
+     */
+    async openSystemEditor() {
+        try {
+            await FileUtils.fileExists(this.filePath);
+        } catch (err) {
+            // File doesn't exist
+            // Create it
+            await FileUtils.writeFile(this.filePath, '');
+        }
+
+        Logger.log('CSS Editor', `Opening file ${this.filePath} in the user's default editor.`);
+
+        // For some reason this doesn't work
+        // if (!electron.shell.openItem(this.filePath))
+        if (!electron.shell.openExternal(`file://${this.filePath}`))
+            throw {message: 'Failed to open system editor.'};
+    }
+
+    /**
+     * Set current state
+     * @param {String} scss Current uncompiled SCSS
+     * @param {String} css Current compiled CSS
+     * @param {String} files Files imported in the SCSS
+     * @param {String} err Current compiler error
+     */
+    setState(scss, css, files, err) {
+        this._scss = scss;
+        this.sendToEditor('set-scss', scss);
+        this.css = css;
+        this.files = files;
+        this.error = err;
+    }
+
+    /**
+     * Current uncompiled scss.
+     */
+    get scss() {
+        return this._scss || '';
+    }
+
+    /**
+     * Set current scss.
+     */
+    set scss(scss) {
+        this.updateScss(scss, true);
+    }
+
+    /**
+     * Current compiled css.
+     */
+    get css() {
+        return this._css || '';
+    }
+
+    /**
+     * Inject compiled css to head.
+     */
+    set css(css) {
+        this._css = css;
         DOM.injectStyle(css, 'bd-customcss');
     }
+
+    /**
+     * Current error.
+     */
+    get error() {
+        return this._error || undefined;
+    }
+
+    /**
+     * Set current error.
+     */
+    set error(err) {
+        this._error = err;
+        this.sendToEditor('scss-error', err);
+    }
+
+    /**
+     * An array of files that are imported in custom CSS.
+     * @return {Array} Files being watched
+     */
+    get files() {
+        return this._files || (this._files = []);
+    }
+
+    /**
+     * Sets all files that are imported in custom CSS.
+     * @param {Array} files Files to watch
+     */
+    set files(files) {
+        this._files = files;
+        if (Settings.get('css', 'default', 'watch-files'))
+            this.watchfiles = files;
+    }
+
+    /**
+     * A filewatcher instance.
+     */
+    get filewatcher() {
+        if (this._filewatcher) return this._filewatcher;
+        this._filewatcher = filewatcher();
+        this._filewatcher.on('change', (file, stat) => {
+            // Recompile SCSS
+            this.recompile();
+        });
+        return this._filewatcher;
+    }
+
+    /**
+     * An array of files that are being watched for changes.
+     * @return {Array} Files being watched
+     */
+    get watchfiles() {
+        return this._watchfiles || (this._watchfiles = []);
+    }
+
+    /**
+     * Sets all files to be watched.
+     * @param {Array} files Files to watch
+     */
+    set watchfiles(files) {
+        for (const file of files) {
+            if (!this.watchfiles.includes(file)) {
+                this.filewatcher.add(file);
+                this.watchfiles.push(file);
+                Logger.log('CSS Editor', `Watching file ${file} for changes`);
+            }
+        }
+
+        for (const index in this.watchfiles) {
+            let file = this.watchfiles[index];
+            while (file && !files.find(f => f === file)) {
+                this.filewatcher.remove(file);
+                this.watchfiles.splice(index, 1);
+                Logger.log('CSS Editor', `No longer watching file ${file} for changes`);
+                file = this.watchfiles[index];
+            }
+        }
+    }
+
+    /**
+     * The path of the file the system editor should save to.
+     * @return {String}
+     */
+    get filePath() {
+        return path.join(Settings.dataPath, 'user.scss');
+    }
+
+    /**
+     * Checks if the system editor's file exists.
+     * @return {Promise}
+     */
+    async fileExists() {
+        try {
+            await FileUtils.fileExists(this.filePath);
+            return true;
+        } catch (err) {
+            return false;
+        }
+    }
+
 }

client/src/modules/database.js

@@ -0,0 +1,61 @@
+/**
+ * BetterDiscord Database Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { ClientIPC } from 'common';
+
+export default class {
+
+    static async init() {
+        return true;
+    }
+
+    /**
+     * Inserts or updates data in the database.
+     * @param {Object} args The record to find
+     * @param {Object} data The new record
+     * @return {Promise}
+     */
+    static async insertOrUpdate(args, data) {
+        try {
+            return ClientIPC.send('bd-dba', { action: 'update', args, data });
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    /**
+     * Finds data in the database.
+     * @param {Object} args The record to find
+     * @return {Promise}
+     */
+    static async find(args) {
+        try {
+            return ClientIPC.send('bd-dba', { action: 'find', args });
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    /**
+     * Find first in the database
+     * @param {Object} args The record to find
+     * @return {Promise} null if record was not found
+     */
+    static async findOne(args) {
+        try {
+            const find = await this.find(args);
+            if (find && find.length) return find[0];
+            return null;
+        } catch (err) {
+            throw err;
+        }
+    }
+
+}

client/src/modules/discordapi.js

@@ -0,0 +1,335 @@
+/**
+ * BetterDiscord Discord API
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { List } from 'structs';
+import { User, Channel, Guild, Message } from 'discordstructs';
+import Reflection from './reflection/index';
+
+export const Modules = {
+    _getModule(name) {
+        const foundModule = Reflection.module.byName(name);
+        if (!foundModule) return null;
+        delete this[name];
+        return this[name] = foundModule;
+    },
+
+    get ChannelSelector() { return this._getModule('ChannelSelector'); },
+    get MessageActions() { return this._getModule('MessageActions'); },
+    get MessageParser() { return this._getModule('MessageParser'); },
+    get MessageStore() { return this._getModule('MessageStore'); },
+    get EmojiUtils() { return this._getModule('EmojiUtils'); },
+    get PermissionUtils() { return this._getModule('Permissions'); },
+    get SortedGuildStore() { return this._getModule('SortedGuildStore'); },
+    get PrivateChannelActions() { return this._getModule('PrivateChannelActions'); },
+    get GuildMemberStore() { return this._getModule('GuildMemberStore'); },
+    get GuildChannelsStore() { return this._getModule('GuildChannelsStore'); },
+    get MemberCountStore() { return this._getModule('MemberCountStore'); },
+    get GuildActions() { return this._getModule('GuildActions'); },
+    get NavigationUtils() { return this._getModule('NavigationUtils'); },
+    get GuildPermissions() { return this._getModule('GuildPermissions'); },
+    get DiscordConstants() { return this._getModule('DiscordConstants'); },
+    get ChannelStore() { return this._getModule('ChannelStore'); },
+    get GuildStore() { return this._getModule('GuildStore'); },
+    get SelectedGuildStore() { return this._getModule('SelectedGuildStore'); },
+    get SelectedChannelStore() { return this._getModule('SelectedChannelStore'); },
+    get UserStore() { return this._getModule('UserStore'); },
+    get RelationshipStore() { return this._getModule('RelationshipStore'); },
+    get RelationshipManager() { return this._getModule('RelationshipManager'); },
+    get ChangeNicknameModal() { return this._getModule('ChangeNicknameModal'); },
+    get UserSettingsStore() { return this._getModule('UserSettingsStore'); },
+    get UserSettingsWindow() { return this._getModule('UserSettingsWindow'); },
+    get UserStatusStore() { return this._getModule('UserStatusStore'); },
+    get ChannelSettingsWindow() { return this._getModule('ChannelSettingsWindow'); },
+    get GuildSettingsWindow() { return this._getModule('GuildSettingsWindow'); },
+    get CreateChannelModal() { return this._getModule('CreateChannelModal'); },
+    get PruneMembersModal() { return this._getModule('PruneMembersModal'); },
+    get NotificationSettingsModal() { return this._getModule('NotificationSettingsModal'); },
+    get PrivacySettingsModal() { return this._getModule('PrivacySettingsModal'); },
+    get UserProfileModal() { return this._getModule('UserProfileModal'); },
+    get APIModule() { return this._getModule('APIModule'); },
+    get UserNoteStore() { return this._getModule('UserNoteStore'); },
+
+    get DiscordPermissions() { return this.DiscordConstants.Permissions; }
+};
+
+export default class DiscordApi {
+
+    static get modules() { return Modules }
+    static get User() { return User }
+    static get Channel() { return Channel }
+    static get Guild() { return Guild }
+    static get Message() { return Message }
+
+    /**
+     * A list of loaded guilds.
+     * @type {List<Guild>}
+     */
+    static get guilds() {
+        const guilds = Modules.GuildStore.getGuilds();
+        return List.from(Object.entries(guilds), ([i, g]) => Guild.from(g));
+    }
+
+    /**
+     * A list of loaded channels.
+     * @type {List<Channel>}
+     */
+    static get channels() {
+        const channels = Modules.ChannelStore.getChannels();
+        return List.from(Object.entries(channels), ([i, c]) => Channel.from(c));
+    }
+
+    /**
+     * A list of loaded users.
+     * @type {List<User>}
+     */
+    static get users() {
+        const users = Modules.UserStore.getUsers();
+        return List.from(Object.entries(users), ([i, u]) => User.from(u));
+    }
+
+    /**
+     * An object mapping guild IDs to their member counts.
+     * @type {Object}
+     */
+    static get memberCounts() {
+        return Modules.MemberCountStore.getMemberCounts();
+    }
+
+    /**
+     * A list of guilds in the order they appear in the server list.
+     * @type {List<Guild>}
+     */
+    static get sortedGuilds() {
+        const guilds = Modules.SortedGuildStore.getSortedGuilds();
+        return List.from(guilds, g => Guild.from(g));
+    }
+
+    /**
+     * An array of guild IDs in the order they appear in the server list.
+     * @type {Number[]}
+     */
+    static get guildPositions() {
+        return Modules.SortedGuildStore.guildPositions;
+    }
+
+    /**
+     * The currently selected guild.
+     * @type {Guild}
+     */
+    static get currentGuild() {
+        const guild = Modules.GuildStore.getGuild(Modules.SelectedGuildStore.getGuildId());
+        if (guild) return Guild.from(guild);
+        return null;
+    }
+
+    /**
+     * The currently selected channel.
+     * @type {Channel}
+     */
+    static get currentChannel() {
+        const channel = Modules.ChannelStore.getChannel(Modules.SelectedChannelStore.getChannelId());
+        if (channel) return Channel.from(channel);
+        return null;
+    }
+
+    /**
+     * The current user.
+     * @type {User}
+     */
+    static get currentUser() {
+        const user = Modules.UserStore.getCurrentUser();
+        if (user) return User.from(user);
+        return null;
+    }
+
+    /**
+     * A list of the current user's friends.
+     * @type {List<User>}
+     */
+    static get friends() {
+        const friends = Modules.RelationshipStore.getFriendIDs();
+        return List.from(friends, id => User.fromId(id));
+    }
+    /**
+     * User settings
+     */
+    static get UserSettings() {
+        return UserSettings;
+    }
+
+}
+
+export class UserSettings {
+    /**
+     * Opens Discord's settings UI.
+     */
+    static open(section = 'ACCOUNT') {
+        Modules.UserSettingsWindow.setSection(section);
+        Modules.UserSettingsWindow.open();
+    }
+
+    /**
+     * The user's current status. Either "online", "idle", "dnd" or "invisible".
+     * @type {String}
+     */
+    static get status() { return Modules.UserSettingsStore.status }
+
+    /**
+     * The user's selected explicit content filter level.
+     * 0 == off, 1 == everyone except friends, 2 == everyone
+     * Configurable in the privacy and safety panel.
+     * @type {Number}
+     */
+    static get explicitContentFilter() { return Modules.UserSettingsStore.explicitContentFilter }
+
+    /**
+     * Whether to disallow direct messages from server members by default.
+     * @type {Boolean}
+     */
+    static get defaultGuildsRestricted() { return Modules.UserSettingsStore.defaultGuildsRestricted }
+
+    /**
+     * An array of guilds to disallow direct messages from their members.
+     * This is bypassed if the member is has another mutual guild with this disabled, or the member is friends with the current user.
+     * Configurable in each server's privacy settings.
+     * @type {Guild[]}
+     */
+    static get restrictedGuildIds() { return Modules.UserSettingsStore.restrictedGuilds }
+
+    static get restrictedGuilds() {
+        return List.from(this.restrictedGuildIds, id => Guild.fromId(id) || id);
+    }
+
+    /**
+     * An array of flags specifying who should be allowed to add the current user as a friend.
+     * If everyone is checked, this will only have one item, "all". Otherwise it has either "mutual_friends", "mutual_guilds", both or neither.
+     * Configurable in the privacy and safety panel.
+     * @type {Array}
+     */
+    static get friendSourceFlags() { return Object.keys(Modules.UserSettingsStore.friendSourceFlags) }
+    static get friendSourceEveryone() { return this.friendSourceFlags.include('all') }
+    static get friendSourceMutual_friends() { return this.friendSourceFlags.include('all') || this.friendSourceFlags.include('mutual_friends') }
+    static get friendSourceMutual_guilds() { return this.friendSourceFlags.include('all') || this.friendSourceFlags.include('mutual_guilds') }
+    static get friendSourceAnyone() { return this.friendSourceFlags.length > 0 }
+
+    /**
+     * Whether to automatically add accounts from other platforms running on the user's computer.
+     * Configurable in the connections panel.
+     * @type {Boolean}
+     */
+    static get detectPlatformAccounts() { return Modules.UserSettingsStore.detectPlatformAccounts }
+
+    /**
+     * The number of seconds Discord will wait for activity before sending mobile push notifications.
+     * Configurable in the notifications panel.
+     * @type {Number}
+     */
+    static get afkTimeout() { return Modules.UserSettingsStore.afkTimeout }
+
+    /**
+     * Whether to display the currently running game as a status message.
+     * Configurable in the games panel.
+     * @type {Boolean}
+     */
+    static get showCurrentGame() { return Modules.UserSettingsStore.showCurrentGame }
+
+    /**
+     * Whether to show images uploaded directly to Discord.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get inlineAttachmentMedia() { return Modules.UserSettingsStore.inlineAttachmentMedia }
+
+    /**
+     * Whether to show images linked in Discord.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get inlineEmbedMedia() { return Modules.UserSettingsStore.inlineEmbedMedia }
+
+    /**
+     * Whether to automatically play GIFs when the Discord window is active without having to hover the mouse over the image.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get autoplayGifs() { return Modules.UserSettingsStore.gifAutoPlay }
+
+    /**
+     * Whether to show content from HTTP[s] links as embeds.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get showEmbeds() { return Modules.UserSettingsStore.renderEmbeds }
+
+    /**
+     * Whether to show a message's reactions.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get showReactions() { return Modules.UserSettingsStore.renderReactions }
+
+    /**
+     * Whether to play animated emoji.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get animateEmoji() { return Modules.UserSettingsStore.animateEmoji }
+
+    /**
+     * Whether to convert ASCII emoticons to emoji.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get convertEmoticons() { return Modules.UserSettingsStore.convertEmoticons }
+
+    /**
+     * Whether to allow playing text-to-speech messages.
+     * Configurable in the text and images panel.
+     * @type {Boolean}
+     */
+    static get allowTts() { return Modules.UserSettingsStore.enableTTSCommand }
+
+    /**
+     * The user's selected theme. Either "dark" or "light".
+     * Configurable in the appearance panel.
+     * @type {String}
+     */
+    static get theme() { return Modules.UserSettingsStore.theme }
+
+    /**
+     * Whether the user has enabled compact mode.
+     * `true` if compact mode is enabled, `false` if cozy mode is enabled.
+     * Configurable in the appearance panel.
+     * @type {Boolean}
+     */
+    static get displayCompact() { return Modules.UserSettingsStore.messageDisplayCompact }
+
+    /**
+     * Whether the user has enabled developer mode.
+     * Currently only adds a "Copy ID" option to the context menu on users, guilds and channels.
+     * Configurable in the appearance panel.
+     * @type {Boolean}
+     */
+    static get developerMode() { return Modules.UserSettingsStore.developerMode }
+
+    /**
+     * The user's selected language code.
+     * Configurable in the language panel.
+     * @type {String}
+     */
+    static get locale() { return Modules.UserSettingsStore.locale }
+
+    /**
+     * The user's timezone offset in hours.
+     * This is not configurable.
+     * @type {Number}
+     */
+    static get timezoneOffset() { return Modules.UserSettingsStore.timezoneOffset }
+}

client/src/modules/editor.js

@@ -0,0 +1,66 @@
+/**
+ * BetterDiscord Editor Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import Module from './imodule';
+import { DOM } from 'ui';
+
+export default new class extends Module {
+
+    get name() { return 'Editor' }
+    get delay() { return false; }
+
+    setInitialState(state) {
+        return {
+            editorBounds: undefined
+        };
+    }
+
+    initialize() {
+        super.initialize();
+        (async () => {
+            try {
+                // TODO this is temporary
+                const userScss = await this.send('readDataFile', 'user.scss');
+                const compiled = await this.send('compileSass', { data: userScss });
+                this.injectStyle('customcss', compiled.css.toString());
+            } catch (err) {
+                console.warn('SCSS Compilation error', err);
+            }
+        })();
+    }
+
+    events(ipc) {
+        ipc.on('editor-runScript', (e, script) => {
+            try {
+                new Function(script)();
+                e.reply('ok');
+            } catch (err) {
+                e.reply({ err: err.stack || err });
+            }
+        });
+
+        ipc.on('editor-injectStyle', (e, { id, style }) => {
+            this.injectStyle(id, style);
+            e.reply('ok');
+        });
+    }
+
+    injectStyle(id, style) {
+        return DOM.injectStyle(style, `userstyle-${id}`);
+    }
+
+    /**
+     * Show editor, flashes if already visible.
+     */
+    async show() {
+        await this.send('editor-open', this.state.editorBounds);
+    }
+
+}

client/src/modules/eventhook.js

@@ -1,5 +1,5 @@
 /**
- * BetterDiscord WebpackModules Module
+ * BetterDiscord Event Hook
  * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
  * All rights reserved.
  * https://betterdiscord.net
@@ -8,17 +8,24 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-import EventListener from './eventlistener';
-import { Utils } from 'common';
+import Reflection from './reflection/index';
+import { MonkeyPatch } from './patcher';
 import Events from './events';
+import EventListener from './eventlistener';
 
-import {
-    MESSAGE_CREATE
-} from '../structs/socketstructs';
-
+import * as SocketStructs from '../structs/socketstructs';
 
+/**
+ * Discord socket event hook
+ * @extends {EventListener}
+ */
 export default class extends EventListener {
 
+    init() {
+        this.ignoreMultiple = -1;
+        this.hook();
+    }
+
     bindings() {
         this.hook = this.hook.bind(this);
     }
@@ -30,55 +37,64 @@ export default class extends EventListener {
     }
 
     hook() {
-
-    }
-
-    get eventsModule() {
-
+        const { Events } = Reflection.modules;
+        MonkeyPatch('BD:EVENTS', Events.prototype).after('emit', (obj, args, retVal) => {
+            const eventId = args.length >= 3 ? args[2].id || -1 : -1;
+            if (eventId === this.ignoreMultiple) return;
+            this.ignoreMultiple = eventId;
+            if (obj.webSocket) this.wsc = obj.webSocket;
+            this.emit(...args);
+        });
+        /*
+        const orig = Events.prototype.emit;
+        Events.prototype.emit = function (...args) {
+            orig.call(this, ...args);
+            self.wsc = this;
+            self.emit(...args);
+        };*/
     }
 
+    /**
+     * Discord emit overload
+     * @param {any} event
+     * @param {any} action
+     * @param {any} data
+     */
     emit(e, action, data) {
         switch (e) {
-            case 'dispatch':
-                return this.dispatch(action, data);
+        case 'dispatch':
+            return this.dispatch(action, data);
         }
     }
 
-    dispatch(e, d) {
-
-        Events.emit('raw-event', { type: e, data: d });
-
-        switch (e) {
-            case this.actions.READ:
-                Events.emit('discord-ready');
-                break;
-            case this.actions.RESUMED:
-                Events.emit('discord-resumed');
-                break;
-            case this.actions.TYPING_START:
-                Events.emit('discord-event', {
-                    type: e,
-                    channelId: d.channel_id,
-                    userId: d.user_id
-                });
-                break;
-            case this.actions.MESSAGE_CREATE:
-                Events.emit('discord-event', { type: e, data: new MESSAGE_CREATE(d) });
-                break;
-            case 'k':
-                Events.emit('discord-event', {
-
-                });
-                break;
-            case this.actions.ACTIVITY_START:
-                Events.emit('discord-event', this.construct(e, d));
-                break;
+    /**
+     * Emit callback
+     * @param {any} event Event
+     * @param {any} data Event data
+     */
+    dispatch(type, data) {
+        Events.emit('raw-event', { type, data });
 
+        if (type === this.actions.READY || type === this.actions.RESUMED) {
+            Events.emit(type, data);
+            return;
         }
+
+        if (!Object.keys(SocketStructs).includes(type)) return;
+        Events.emit(`discord:${type}`, new SocketStructs[type](data));
     }
 
+    get SocketStructs() {
+        return SocketStructs;
+    }
+
+    /**
+     * All known socket actions
+     */
     get actions() {
-        return {
+        if (this._actions) return this._actions;
+
+        return this._actions = {
             READY: 'READY', // Socket ready
             RESUMED: 'RESUMED', // Socket resumed
             TYPING_START: 'TYPING_START', // User typing start
@@ -137,7 +153,7 @@ export default class extends EventListener {
             LFG_LISTING_CREATE: 'LFG_LISTING_CREATE', // No groups here
             LFG_LISTING_DELETE: 'LFG_LISTING_DELETE', // Thank you
             BRAINTREE_POPUP_BRIDGE_CALLBACK: 'BRAINTREE_POPUP_BRIDGE_CALLBACK' // What
-        }
+        };
     }
 
 }

client/src/modules/eventlistener.js

@@ -14,7 +14,7 @@ import Events from './events';
 export default class extends Module {
 
     events() {
-        for (let event of this.eventBindings) {
+        for (const event of this.eventBindings) {
             Events.on(event.id, event.callback);
         }
     }

client/src/modules/events.js

@@ -12,16 +12,43 @@ import { EventEmitter } from 'events';
 const emitter = new EventEmitter();
 
 export default class {
-    static on(eventName, callBack) {
-        emitter.on(eventName, callBack);
+
+    /**
+     * Adds an event listener.
+     * @param {String} event The event to listen for
+     * @param {Function} callback The function to call when the event is emitted
+     */
+    static on(event, callback) {
+        emitter.on(event, callback);
     }
 
-    static off(eventName, callBack) {
-        emitter.removeListener(eventName, callBack);
+    /**
+     * Adds an event listener that is only called once.
+     * @param {String} event The event to listen for
+     * @param {Function} callback The function to call when the event is emitted
+     */
+    static once(event, callback) {
+        emitter.once(event, callback);
     }
 
-    static emit(...args) {
-        emitter.emit(...args);
+    /**
+     * Removes an event listener.
+     * @param {String} event The event to remove
+     * @param {Function} callback The listener to remove
+     */
+    static off(event, callback) {
+        emitter.removeListener(event, callback);
+    }
+
+    static get removeListener() { return this.off }
+
+    /**
+     * Emits an event
+     * @param {String} event The event to emit
+     * @param {Any} ...data Data to pass to the event listeners
+     */
+    static emit(event, ...data) {
+        emitter.emit(event, ...data);
     }
 
 }

client/src/modules/eventswrapper.js

@@ -0,0 +1,55 @@
+/**
+ * BetterDiscord Events Wrapper Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+const eventemitters = new WeakMap();
+
+export default class EventsWrapper {
+
+    constructor(eventemitter, bind) {
+        eventemitters.set(this, eventemitter);
+        this.bind = bind || this;
+    }
+
+    get eventSubs() {
+        return this._eventSubs || (this._eventSubs = []);
+    }
+
+    get on() { return this.subscribe }
+    subscribe(event, callback) {
+        if (this.eventSubs.find(e => e.event === event && e.callback === callback)) return;
+        const boundCallback = (...args) => callback.apply(this.bind, args);
+        this.eventSubs.push({ event, callback, boundCallback });
+        eventemitters.get(this).on(event, boundCallback);
+    }
+
+    once(event, callback) {
+        if (this.eventSubs.find(e => e.event === event && e.callback === callback)) return;
+        const boundCallback = (...args) => this.off(event, callback) && callback.apply(this.bind, args);
+        this.eventSubs.push({ event, callback, boundCallback });
+        eventemitters.get(this).on(event, boundCallback);
+    }
+
+    get off() { return this.unsubscribe }
+    unsubscribe(event, callback) {
+        for (const index in this.eventSubs) {
+            if (this.eventSubs[index].event !== event || (callback && this.eventSubs[index].callback === callback)) continue;
+            eventemitters.get(this).removeListener(event, this.eventSubs[index].boundCallback);
+            this.eventSubs.splice(index, 1);
+        }
+    }
+
+    unsubscribeAll() {
+        for (const event of this.eventSubs) {
+            eventemitters.get(this).removeListener(event.event, event.boundCallback);
+        }
+        this.eventSubs.splice(0, this.eventSubs.length);
+    }
+
+}

client/src/modules/extmodule.js

@@ -0,0 +1,23 @@
+/**
+ * BetterDiscord External Module Base
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import Globals from './globals';
+import Content from './content';
+
+export default class ExtModule extends Content {
+
+    constructor(internals) {
+        super(internals);
+        this.__require = Globals.require(this.paths.mainPath);
+    }
+
+    get type() { return 'module' }
+
+}

client/src/modules/extmodulemanager.js

@@ -0,0 +1,62 @@
+/**
+ * BetterDiscord External Module Manager Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import ContentManager from './contentmanager';
+import ExtModule from './extmodule';
+
+export default class extends ContentManager {
+
+    static get localModules() {
+        return this.localContent;
+    }
+
+    static get contentType() {
+        return 'module';
+    }
+
+    static get moduleName() {
+        return 'Ext Module Manager';
+    }
+
+    static get pathId() {
+        return 'modules';
+    }
+
+    static get loadAllModules() {
+        return this.loadAllContent;
+    }
+
+    static get refreshModules() { return this.refreshContent }
+
+    static get loadContent() { return this.loadModule }
+    static async loadModule(paths, configs, info, main) {
+        return new ExtModule({
+            configs, info, main,
+            paths: {
+                contentPath: paths.contentPath,
+                dirName: paths.dirName,
+                mainPath: paths.mainPath
+            }
+        });
+    }
+
+    static get isExtModule() { return this.isThisContent }
+    static isThisContent(module) {
+        return module instanceof ExtModule;
+    }
+
+    static get findModule() { return this.findContent }
+    static get getModuleIndex() { return this.getContentIndex }
+    static get getModuleByName() { return this.getContentByName }
+    static get getModuleById() { return this.getContentById }
+    static get getModuleByPath() { return this.getContentByPath }
+    static get getModuleByDirName() { return this.getContentByDirName }
+
+}

client/src/modules/globals.js

@@ -8,14 +8,23 @@
  * LICENSE file in the root directory of this source tree.
 */
 
+import path from 'path';
+import sparkplug from 'sparkplug';
+import { ClientIPC } from 'common';
 import Module from './module';
 import Events from './events';
-import { ClientIPC } from 'bdipc';
 
 export default new class extends Module {
 
     constructor(args) {
         super(args);
+
+        // webpack replaces this with the normal require function
+        // eslint-disable-next-line no-undef
+        this.require = __non_webpack_require__;
+    }
+
+    initg() {
         this.first();
     }
 
@@ -25,28 +34,24 @@ export default new class extends Module {
         this.getObject = this.getObject.bind(this);
     }
 
-    first() {
-        (async() => {
-            const config = await ClientIPC.send('getConfig');
-            this.setState(config);
+    async first() {
+        const config = await ClientIPC.send('getConfig');
+        this.setState({ config });
 
-            // This is for Discord to stop error reporting :3
-            window.BetterDiscord = {
-                'version': config.version,
-                'v': config.version
-            };
-            window.jQuery = {};
+        // This is for Discord to stop error reporting :3
+        window.BetterDiscord = {
+            version: config.version,
+            v: config.version
+        };
+        window.jQuery = {};
 
-            if (window.__bd) {
-                this.setState(window.__bd);
-                window.__bd = {
-                    setWS: this.setWS
-                }
-            }
+        if (sparkplug.bd) {
+            this.setState({ bd: sparkplug.bd });
+            sparkplug.bd.setWS = this.setWS;
+        }
 
-            Events.emit('global-ready');
-            Events.emit('socket-created', this.state.wsHook);
-        })();
+        Events.emit('global-ready');
+        Events.emit('socket-created', this.state.wsHook);
     }
 
     setWS(wSocket) {
@@ -57,7 +62,43 @@ export default new class extends Module {
     }
 
     getObject(name) {
-        return this.state[name];
+        return this.config[name] || this.bd[name];
+    }
+
+    get bd() {
+        return this.state.bd;
+    }
+
+    get localStorage() {
+        return this.bd.localStorage;
+    }
+
+    get webSocket() {
+        return this.bd.wsHook;
+    }
+
+    get WebSocket() {
+        return this.bd.wsOrig;
+    }
+
+    get ignited() {
+        return this.bd.ignited;
+    }
+
+    get config() {
+        return this.state.config;
+    }
+
+    get paths() {
+        return this.config.paths;
+    }
+
+    getPath(id) {
+        return this.paths.find(path => path.id === id).path;
+    }
+
+    get version() {
+        return this.config.versions.core;
     }
 
 }

client/src/modules/imodule.js

@@ -0,0 +1,73 @@
+/**
+ * BetterDiscord Module Base
+ * Copyright (c) 2015-present JsSucks - https://github.com/JsSucks
+ * All rights reserved.
+ * https://github.com/JsSucks - https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+/**
+ * Base Module that every non-static module should extend
+ */
+
+import { ClientLogger as Logger, ClientIPC } from 'common';
+
+export default class Module {
+
+    constructor(args) {
+        this.__ = {
+            state: args || {},
+            args
+        };
+        this.setState = this.setState.bind(this);
+
+        if (this.delay) { // If delay is set then module is set to load delayed from modulemanager
+            this.initialize = this.initialize.bind(this);
+            this.init = this.initialize;
+        } else {
+            this.initialize();
+            this.init = () => { };
+        }
+    }
+
+    initialize() {
+        if (this.bindings) this.bindings();
+        if (this.setInitialState) this.setState(this.setInitialState(this.state));
+        if (this.events) this.events(ClientIPC);
+    }
+
+    setState(newState) {
+        const oldState = Object.assign({}, this.state);
+        Object.assign(this.state, newState);
+        if (this.stateChanged) this.stateChanged(oldState, newState);
+    }
+
+    set args(t) { }
+    get args() { return this.__.args; }
+
+    set state(state) { return this.__.state = state; }
+    get state() { return this.__.state; }
+
+    async send(channel, message) {
+        return ClientIPC.send(channel, message);
+    }
+
+    log(msg) {
+        Logger.log(this.name, msg);
+    }
+
+    warn(msg) {
+        Logger.log(this.name, msg);
+    }
+
+    err(msg) {
+        Logger.log(this.name, msg);
+    }
+
+    info(msg) {
+        Logger.log(this.name, msg);
+    }
+
+}

client/src/modules/module.js

@@ -5,20 +5,19 @@
  * https://github.com/JsSucks - https://betterdiscord.net
  *
  * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree. 
-*/
-
-/*
-Base Module that every non-static module should extend
+ * LICENSE file in the root directory of this source tree.
 */
 
+/**
+ * Base Module that every non-static module should extend
+ */
 export default class Module {
 
     constructor(args) {
         this.__ = {
             state: args || {},
             args
-        }
+        };
         this.setState = this.setState.bind(this);
         this.initialize();
     }
@@ -38,7 +37,6 @@ export default class Module {
     set args(t) { }
     get args() { return this.__.args; }
 
-
     set state(state) { return this.__.state = state; }
     get state() { return this.__.state; }
 

client/src/modules/modulemanager.js

@@ -8,27 +8,39 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-/*Module Manager initializes all modules when everything is ready*/
-
-import { Events, SocketProxy, EventHook } from 'modules';
-import { ProfileBadges } from 'ui';
+import { ClientLogger as Logger } from 'common';
+import { SocketProxy, EventHook } from 'modules';
+import { ProfileBadges, ClassNormaliser } from 'ui';
+import Updater from './updater';
 
+/**
+ * Module Manager initializes all modules when everything is ready
+ */
 export default class {
 
+    /**
+     * An array of modules.
+     */
     static get modules() {
         return this._modules ? this._modules : (this._modules = [
             new ProfileBadges(),
+            new ClassNormaliser(),
             new SocketProxy(),
-            new EventHook()
+            new EventHook(),
+            Updater
         ]);
     }
 
+    /**
+     * Initializes all modules.
+     * @return {Promise}
+     */
     static async initModules() {
-        for (let module of this.modules) {
+        for (const module of this.modules) {
             try {
                 if (module.init && module.init instanceof Function) module.init();
             } catch (err) {
-                console.log(`Failed to initialize module: ${err}`);
+                Logger.err('Module Manager', ['Failed to initialize module:', err]);
             }
         }
         return true;

client/src/modules/modules.js

@@ -1,12 +1,31 @@
 export { default as Events } from './events';
-export { default as Settings } from './settings';
 export { default as CssEditor } from './csseditor';
+export { default as Editor } from './editor';
+export { default as Globals } from './globals';
+export { default as Settings } from './settings';
+export { default as Database } from './database';
+export { default as Updater } from './updater';
+
+export { default as ModuleManager } from './modulemanager';
 export { default as PluginManager } from './pluginmanager';
 export { default as ThemeManager } from './thememanager';
-export { default as Globals } from './globals';
+export { default as ExtModuleManager } from './extmodulemanager';
+export { default as Permissions } from './permissionmanager';
+
+export { default as EventsWrapper } from './eventswrapper';
 export { default as Vendor } from './vendor';
-export { default as WebpackModules } from './webpackmodules';
-export { default as ModuleManager } from './modulemanager';
+
+export * from './webpackmodules';
+export * from './patcher';
+export * from './reactcomponents';
+export { default as Module } from './module';
 export { default as EventListener } from './eventlistener';
 export { default as SocketProxy } from './socketproxy';
 export { default as EventHook } from './eventhook';
+export { default as DiscordApi, Modules as DiscordApiModules } from './discordapi';
+export { default as BdWebApi } from './bdwebapi';
+export { default as Connectivity } from './connectivity';
+export { default as Security } from './security';
+export { default as Cache } from './cache';
+export { default as Reflection } from './reflection/index';
+export { default as PackageInstaller } from './packageinstaller';

client/src/modules/packageinstaller.js

@@ -0,0 +1,178 @@
+import EventListener from './eventlistener';
+import asar from 'asar';
+import fs from 'fs';
+import path from 'path';
+import rimraf from 'rimraf';
+
+import { request } from 'vendor';
+import { Modals } from 'ui';
+import { Utils, FileUtils } from 'common';
+import PluginManager from './pluginmanager';
+import Globals from './globals';
+import Security from './security';
+import Reflection from './reflection';
+import DiscordApi from './discordapi';
+import ThemeManager from './thememanager';
+import { MonkeyPatch } from './patcher';
+import { DOM } from 'ui';
+
+export default class PackageInstaller {
+
+    /**
+     * Handler for drag and drop package install
+     * @param {String} filePath Path to local file
+     * @param {Boolean} canUpload If the user can upload files in current window
+     * @returns {Number} returns action code from modal
+     */
+    static async dragAndDropHandler(filePath, canUpload) {
+        try {
+            const config = JSON.parse(asar.extractFile(filePath, 'config.json').toString());
+            const { info, main } = config;
+
+            let icon = null;
+            if (info.icon && info.icon_type) {
+                const extractIcon = asar.extractFile(filePath, info.icon);
+                icon = `data:${info.icon_type};base64,${Utils.arrayBufferToBase64(extractIcon)}`;
+            }
+
+            const isPlugin = info.type && info.type === 'plugin' || main.endsWith('.js');
+
+            // Show install modal
+            const modalResult = await Modals.installModal(isPlugin ? 'plugin' : 'theme', config, filePath, icon, canUpload).promise;
+            return modalResult;
+        } catch (err) {
+            console.log(err);
+        }
+    }
+
+    /**
+     * Hash and verify a package
+     * @param {Byte[]|String} bytesOrPath byte array of binary or path to local file
+     * @param {String} id Package id
+     */
+    static async verifyPackage(bytesOrPath, id) {
+        const bytes = typeof bytesOrPath === 'string' ? fs.readFileSync(bytesOrPath) : bytesOrPath;
+        // Temporary hash to simulate response from server
+        const tempVerified = ['2e3532ee366816adc37b0f478bfef35e03f96e7aeee9b115f5918ef6a4e94de8', '06a2eb4e37b926354ab80cd83207db67e544c932e9beddce545967a21f8db5aa'];
+        const hashBytes = Security.hash('sha256', bytes, 'hex');
+
+        return tempVerified.includes(hashBytes);
+    }
+
+    // TODO lots of stuff
+    /**
+     * Installs or updates defined package
+     * @param {Byte[]|String} bytesOrPath byte array of binary or path to local file
+     * @param {String} nameOrId Package name
+     * @param {Boolean} update Does an older version already exist
+     */
+    static async installPackage(bytesOrPath, nameOrId, contentType, update = false) {
+        let outputPath = null;
+        try {
+
+            const bytes = typeof bytesOrPath === 'string' ? fs.readFileSync(bytesOrPath) : bytesOrPath;
+            const outputName = `${nameOrId}.bd`;
+
+            outputPath = path.join(Globals.getPath(`${contentType}s`), outputName);
+            fs.writeFileSync(outputPath, bytes);
+
+            const manager = contentType === 'plugin' ? PluginManager : ThemeManager;
+
+            if (!update) return manager.preloadPackedContent(outputName);
+
+            const oldContent = manager.findContent(nameOrId);
+
+            await oldContent.unload(true);
+
+            if (oldContent.packed && oldContent.packageName !== nameOrId) {
+                await FileUtils.deleteFile(oldContent.packagePath).catch(err => null);
+            }
+            await FileUtils.recursiveDeleteDirectory(oldContent.contentPath).catch(err => null);
+
+            return manager.preloadPackedContent(outputName);
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    /**
+     * Install package from remote location. Only github/bdapi is supported.
+     * @param {String} remoteLocation Remote resource location
+     */
+    static async installRemotePackage(remoteLocation) {
+        try {
+            const { hostname } = Object.assign(document.createElement('a'), { href: remoteLocation });
+            if (hostname !== 'api.github.com' && hostname !== 'secretbdapi') throw 'Invalid host!';
+
+            const options = {
+                uri: remoteLocation,
+                encoding: null,
+                headers: {
+                    'User-Agent': 'BetterDiscordClient',
+                    'Accept': 'application/octet-stream'
+                }
+            };
+
+            const response = await request.get(options);
+            const outputPath = path.join(Globals.getPath('tmp'), Security.hash('sha256', response, 'hex'));
+            fs.writeFileSync(outputPath, response);
+            console.log('response', response);
+            console.log('output', outputPath);
+
+            await this.dragAndDropHandler(outputPath);
+            rimraf(outputPath, err => {
+                if (err) console.log(err);
+            });
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    static async handleDrop(stateNode, e, original) {
+        if (!e.dataTransfer.files.length || !e.dataTransfer.files[0].name.endsWith('.bd')) return original && original.call(stateNode, e);
+
+        e.preventDefault();
+        e.stopPropagation();
+        e.stopImmediatePropagation();
+        if (stateNode) stateNode.clearDragging();
+
+        const currentChannel = DiscordApi.currentChannel;
+        const canUpload = currentChannel ?
+            currentChannel.checkPermissions(Reflection.modules.DiscordConstants.Permissions.SEND_MESSAGES) &&
+            currentChannel.checkPermissions(Reflection.modules.DiscordConstants.Permissions.ATTACH_FILES) : false;
+
+        const files = Array.from(e.dataTransfer.files).slice(0);
+        const actionCode = await this.dragAndDropHandler(e.dataTransfer.files[0].path, canUpload);
+
+        if (actionCode === 0 && stateNode) stateNode.promptToUpload(files, currentChannel.id, true, !e.shiftKey);
+    }
+
+    /**
+     * Patches Discord upload area for .bd files
+     */
+    static async uploadAreaPatch(UploadArea) {
+        // Add a listener to root for when not in a channel
+        const root = DOM.getElement('#app-mount');
+        const rootHandleDrop = this.handleDrop.bind(this, undefined);
+        root.addEventListener('drop', rootHandleDrop);
+
+        const unpatchUploadAreaHandleDrop = MonkeyPatch('BD:ReactComponents', UploadArea.component.prototype).instead('handleDrop', (component, [e], original) => this.handleDrop(component, e, original));
+
+        this.unpatchUploadArea = () => {
+            unpatchUploadAreaHandleDrop();
+            root.removeEventListener('drop', rootHandleDrop);
+            this.unpatchUploadArea = undefined;
+        };
+
+        for (const element of document.querySelectorAll(UploadArea.important.selector)) {
+            const stateNode = Reflection.DOM(element).getComponentStateNode(UploadArea);
+
+            element.removeEventListener('drop', stateNode.handleDrop);
+            stateNode.handleDrop = UploadArea.component.prototype.handleDrop.bind(stateNode);
+            element.addEventListener('drop', stateNode.handleDrop);
+
+            stateNode.forceUpdate();
+        }
+    }
+
+}

client/src/modules/patcher.js

@@ -0,0 +1,221 @@
+/**
+ * BetterDiscord Component Patcher
+ * Copyright (c) 2015-present JsSucks - https://github.com/JsSucks
+ * All rights reserved.
+ * https://github.com/JsSucks - https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import Reflection from './reflection/index';
+import { ClientLogger as Logger } from 'common';
+
+/**
+ * Function with no arguments and no return value that may be called to revert changes made by {@link Patcher}, restoring (unpatching) original method.
+ * @callback Patcher~unpatch
+ */
+
+/**
+ * A callback that modifies method logic. This callback is called on each call of the original method and is provided all data about original call. Any of the data can be modified if necessary, but do so wisely.
+ *
+ * The third argument for the callback will be `undefined` for `before` patches. `originalFunction` for `instead` patches and `returnValue` for `after` patches.
+ *
+ * @callback Patcher~patchCallback
+ * @param {object} thisObject - `this` in the context of the original function.
+ * @param {arguments} arguments - The original arguments of the original function.
+ * @param {(function|*)} extraValue - For `instead` patches, this is the original function from the module. For `after` patches, this is the return value of the function.
+ * @return {*} Makes sense only when using an `instead` or `after` patch. If something other than `undefined` is returned, the returned value replaces the value of `returnValue`. If used for `before` the return value is ignored.
+ */
+
+export class Patcher {
+
+    static get patches() { return this._patches || (this._patches = []) }
+
+    /**
+     * Returns all the patches done by a specific caller
+     * @param {string} id - Name of the patch caller
+     * @method
+     */
+    static getPatchesByCaller(id) {
+        if (!id) return [];
+        const patches = [];
+        for (const patch of this.patches) {
+            for (const childPatch of patch.children) {
+                if (childPatch.caller === id) patches.push(childPatch);
+            }
+        }
+        return patches;
+    }
+
+    /**
+     * Unpatches all patches passed, or when a string is passed unpatches all
+     * patches done by that specific caller.
+     * @param {Array|string} patches - Either an array of patches to unpatch or a caller name
+     */
+    static unpatchAll(patches) {
+        if (typeof patches === 'string')
+            patches = this.getPatchesByCaller(patches);
+
+        for (const patch of patches) {
+            patch.unpatch();
+        }
+    }
+
+    static resolveModule(module) {
+        if (module instanceof Function || (module instanceof Object)) return module;
+        if (typeof module === 'string') return Reflection.module.byName(module);
+        return null;
+    }
+
+    static overrideFn(patch) {
+        return function () {
+            let retVal = undefined;
+            if (!patch.children || !patch.children.length) return patch.originalFunction.apply(this, arguments);
+            for (const superPatch of patch.children.filter(c => c.type === 'before')) {
+                try {
+                    superPatch.callback(this, arguments);
+                } catch (err) {
+                    Logger.err(`Patcher:${patch.id}`, err);
+                }
+            }
+
+            const insteads = patch.children.filter(c => c.type === 'instead');
+            if (!insteads.length) {
+                retVal = patch.originalFunction.apply(this, arguments);
+            } else {
+                for (const insteadPatch of insteads) {
+                    try {
+                        const tempReturn = insteadPatch.callback(this, arguments, patch.originalFunction.bind(this));
+                        if (typeof tempReturn !== 'undefined') retVal = tempReturn;
+                    } catch (err) {
+                        Logger.err(`Patcher:${patch.id}`, err);
+                    }
+                }
+            }
+
+            for (const slavePatch of patch.children.filter(c => c.type === 'after')) {
+                try {
+                    const tempReturn = slavePatch.callback(this, arguments, retVal, r => retVal = r);
+                    if (typeof tempReturn !== 'undefined') retVal = tempReturn;
+                } catch (err) {
+                    Logger.err(`Patcher:${patch.id}`, err);
+                }
+            }
+            return retVal;
+        }
+    }
+
+    static rePatch(patch) {
+        if (patch.module instanceof Array && typeof patch.functionName === 'number')
+            patch.module.splice(patch.functionName, 1, patch.proxyFunction = this.overrideFn(patch));
+        else patch.proxyFunction = patch.module[patch.functionName] = this.overrideFn(patch);
+    }
+
+    static pushPatch(caller, id, module, functionName) {
+        const patch = {
+            caller,
+            id,
+            module,
+            functionName,
+            originalFunction: module[functionName],
+            proxyFunction: null,
+            revert: () => { // Calling revert will destroy any patches added to the same module after this
+                patch.module[patch.functionName] = patch.originalFunction;
+                patch.proxyFunction = null;
+                patch.children = [];
+            },
+            counter: 0,
+            children: []
+        };
+        patch.proxyFunction = module[functionName] = this.overrideFn(patch);
+        return this.patches.push(patch), patch;
+    }
+
+    /**
+     * This method patches onto another function, allowing your code to run beforehand.
+     * Using this, you are also able to modify the incoming arguments before the original method is run.
+     *
+     * @param {string} caller - Name of the caller of the patch function. Using this you can undo all patches with the same name using {@link Patcher#unpatchAll}.
+     * @param {object} unresolvedModule - Object with the function to be patched. Can also patch an object's prototype.
+     * @param {string} functionName - Name of the method to be patched
+     * @param {Patcher~patchCallback} callback - Function to run before the original method
+     * @param {string} [displayName] You can provide meaningful name for class/object provided in `what` param for logging purposes. By default, this function will try to determine name automatically.
+     * @return {Patcher~unpatch} Function with no arguments and no return value that should be called to cancel (unpatch) this patch. You should save and run it when your plugin is stopped.
+     */
+    static before(caller, unresolvedModule, functionName, callback, displayName) { return this.pushChildPatch(caller, unresolvedModule, functionName, callback, displayName, 'before') }
+
+    /**
+     * This method patches onto another function, allowing your code to run afterwards.
+     * Using this, you are also able to modify the return value, using the return of your code instead.
+     *
+     * @param {string} caller - Name of the caller of the patch function. Using this you can undo all patches with the same name using {@link Patcher#unpatchAll}.
+     * @param {object} unresolvedModule - Object with the function to be patched. Can also patch an object's prototype.
+     * @param {string} functionName - Name of the method to be patched
+     * @param {Patcher~patchCallback} callback - Function to run after the original method
+     * @param {string} [displayName] You can provide meaningful name for class/object provided in `what` param for logging purposes. By default, this function will try to determine name automatically.
+     * @return {Patcher~unpatch} Function with no arguments and no return value that should be called to cancel (unpatch) this patch. You should save and run it when your plugin is stopped.
+     */
+    static after(caller, unresolvedModule, functionName, callback, displayName) { return this.pushChildPatch(caller, unresolvedModule, functionName, callback, displayName, 'after') }
+
+    /**
+     * This method patches onto another function, allowing your code to run instead, preventing the running of the original code.
+     * Using this, you are also able to modify the return value, using the return of your code instead.
+     *
+     * @param {string} caller - Name of the caller of the patch function. Using this you can undo all patches with the same name using {@link Patcher#unpatchAll}.
+     * @param {object} unresolvedModule - Object with the function to be patched. Can also patch an object's prototype.
+     * @param {string} functionName - Name of the method to be patched
+     * @param {Patcher~patchCallback} callback - Function to run instead of the original method
+     * @param {string} [displayName] You can provide meaningful name for class/object provided in `what` param for logging purposes. By default, this function will try to determine name automatically.
+     * @return {Patcher~unpatch} Function with no arguments and no return value that should be called to cancel (unpatch) this patch. You should save and run it when your plugin is stopped.
+     */
+    static instead(caller, unresolvedModule, functionName, callback, displayName) { return this.pushChildPatch(caller, unresolvedModule, functionName, callback, displayName, 'instead') }
+
+    /**
+     * This method patches onto another function, allowing your code to run before, instead or after the original function.
+     * Using this you are able to modify the incoming arguments before the original function is run as well as the return
+     * value before the original function actually returns.
+     *
+     * @param {string} caller - Name of the caller of the patch function. Using this you can undo all patches with the same name using {@link Patcher#unpatchAll}.
+     * @param {object} unresolvedModule - Object with the function to be patched. Can also patch an object's prototype.
+     * @param {string} functionName - Name of the method to be patched
+     * @param {Patcher~patchCallback} callback - Function to run after the original method
+     * @param {string} [displayName] You can provide meaningful name for class/object provided in `what` param for logging purposes. By default, this function will try to determine name automatically.
+     * @param {string} [type=after] - Determines whether to run the function `before`, `instead`, or `after` the original.
+     * @return {Patcher~unpatch} Function with no arguments and no return value that should be called to cancel (unpatch) this patch. You should save and run it when your plugin is stopped.
+     */
+    static pushChildPatch(caller, unresolvedModule, functionName, callback, displayName, type = 'after') {
+        const module = this.resolveModule(unresolvedModule);
+        if (!module || !module[functionName] || !(module[functionName] instanceof Function)) return null;
+        displayName = typeof unresolvedModule === 'string' ? unresolvedModule :
+            displayName || module.displayName || module.name || module.constructor.displayName || module.constructor.name;
+        const patchId = `${displayName}:${functionName}:${caller}`;
+
+        const patch = this.patches.find(p => p.module == module && p.functionName == functionName) || this.pushPatch(caller, patchId, module, functionName);
+        if (!patch.proxyFunction) this.rePatch(patch);
+        const child = {
+            caller,
+            type,
+            id: patch.counter,
+            callback,
+            unpatch: () => {
+                patch.children.splice(patch.children.findIndex(cpatch => cpatch.id === child.id && cpatch.type === type), 1);
+                if (patch.children.length <= 0) {
+                    const patchNum = this.patches.findIndex(p => p.module == module && p.functionName == functionName);
+                    this.patches[patchNum].revert();
+                    this.patches.splice(patchNum, 1);
+                }
+            }
+        };
+        patch.children.push(child);
+        patch.counter++;
+        return child.unpatch;
+    }
+
+}
+
+export const MonkeyPatch = (caller, module, displayName) => ({
+    before: (functionName, callBack) => Patcher.before(caller, module, functionName, callBack, displayName),
+    after: (functionName, callBack) => Patcher.after(caller, module, functionName, callBack, displayName),
+    instead: (functionName, callBack) => Patcher.instead(caller, module, functionName, callBack, displayName)
+});

client/src/modules/permissionmanager.js

@@ -0,0 +1,44 @@
+/**
+ * BetterDiscord Permission Manager
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+const PermissionMap = {
+    IDENTIFY: {
+        HEADER: 'Access your account information',
+        BODY: 'Allows :NAME: to read your account information (excluding user token).'
+    },
+    READ_MESSAGES: {
+        HEADER: 'Read all messages',
+        BODY: 'Allows :NAME: to read all messages accessible through your Discord account.'
+    },
+    SEND_MESSAGES: {
+        HEADER: 'Send messages',
+        BODY: 'Allows :NAME: to send messages on your behalf.'
+    },
+    DELETE_MESSAGES: {
+        HEADER: 'Delete messages',
+        BODY: 'Allows :NAME: to delete messages on your behalf.'
+    },
+    EDIT_MESSAGES: {
+        HEADER: 'Edit messages',
+        BODY: 'Allows :NAME: to edit messages on your behalf.'
+    },
+    JOIN_SERVERS: {
+        HEADER: 'Join servers for you',
+        BODY: 'Allows :NAME: to join servers on your behalf.'
+    }
+}
+
+export default class {
+
+    static permissionText(permission) {
+        return PermissionMap[permission];
+    }
+
+}

client/src/modules/plugin.js

@@ -8,85 +8,22 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-import { FileUtils } from 'common';
+import PluginManager from './pluginmanager';
+import Content from './content';
 
-export default class {
+export default class Plugin extends Content {
 
-    constructor(pluginInternals) {
-        this.__pluginInternals = pluginInternals;
-        this.saveSettings = this.saveSettings.bind(this);
-        this.hasSettings = this.pluginConfig && this.pluginConfig.length > 0;
-        this.start = this.start.bind(this);
-        this.stop = this.stop.bind(this);
+    get type() { return 'plugin' }
+
+    get start() { return this.enable }
+    get stop() { return this.disable }
+
+    reload(force) {
+        return PluginManager.reloadPlugin(this, force);
     }
 
-    get configs() { return this.__pluginInternals.configs }
-    get info() { return this.__pluginInternals.info }
-    get icon() { return this.info.icon }
-    get paths() { return this.__pluginInternals.paths }
-    get main() { return this.__pluginInternals.main }
-    get defaultConfig() { return this.configs.defaultConfig }
-    get userConfig() { return this.configs.userConfig }
-    get name() { return this.info.name }
-    get authors() { return this.info.authors }
-    get version() { return this.info.version }
-    get pluginPath() { return this.paths.contentPath }
-    get dirName() { return this.paths.dirName }
-    get enabled() { return this.userConfig.enabled }
-    get pluginConfig() { return this.userConfig.config }
-
-    getSetting(settingId) {
-        return this.userConfig.config.find(setting => setting.id === settingId);
-    }
-
-    async sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-
-    async saveSettings(newSettings) {
-        if (newSettings) {
-            for (let category of newSettings) {
-                const oldCategory = this.pluginConfig.find(c => c.category === category.category);
-                for (let setting of category.settings) {
-                    const oldSetting = oldCategory.settings.find(s => s.id === setting.id);
-                    if (oldSetting.value === setting.value) continue;
-                    oldSetting.value = setting.value;
-                    if (this.settingChanged) this.settingChanged(category.category, setting.id, setting.value);
-                }
-            }
-        }
-
-        try {
-            await FileUtils.writeFile(`${this.pluginPath}/user.config.json`, JSON.stringify({ enabled: this.enabled, config: this.pluginConfig }));
-        } catch (err) {
-            throw err;
-        }
-
-        if (this.settingsChanged) this.settingsChanged(this.pluginConfig);
-
-        return this.pluginConfig;
-    }
-
-    start() {
-        if (this.onStart) {
-            const started = this.onStart();
-            if (!started) return false;
-        }
-
-        this.userConfig.enabled = true;
-        this.saveSettings();
-        return true;
-    }
-
-    stop() {
-        if (this.onStop) {
-            const stopped = this.onStop();
-            if (!stopped) return false;
-        }
-
-        this.userConfig.enabled = false;
-        this.saveSettings();
-        return true;
+    unload(force) {
+        return PluginManager.unloadPlugin(this, force);
     }
 
 }

client/src/modules/pluginapi.js

@@ -0,0 +1,624 @@
+/**
+ * BetterDiscord Plugin API
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { EmoteModule } from 'builtin';
+import { SettingsSet, SettingsCategory, Setting, SettingsScheme } from 'structs';
+import { BdMenu, Modals, DOM, DOMObserver, VueInjector, Toasts, Notifications, BdContextMenu, DiscordContextMenu } from 'ui';
+import * as CommonComponents from 'commoncomponents';
+import { default as Components } from '../ui/components/generic';
+import { Utils, Filters, ClientLogger as Logger, ClientIPC, AsyncEventEmitter } from 'common';
+import Settings from './settings';
+import ExtModuleManager from './extmodulemanager';
+import PluginManager from './pluginmanager';
+import ThemeManager from './thememanager';
+import Events from './events';
+import EventsWrapper from './eventswrapper';
+import Reflection from './reflection/index';
+import DiscordApi from './discordapi';
+import { ReactComponents, ReactHelpers } from './reactcomponents';
+import { Patcher, MonkeyPatch } from './patcher';
+import GlobalAc from '../ui/autocomplete';
+import Vue from 'vue';
+import path from 'path';
+import Globals from './globals';
+
+export default class PluginApi {
+
+    constructor(pluginInfo, pluginPath) {
+        this.pluginInfo = pluginInfo;
+        this.pluginPath = pluginPath;
+
+        this.Events = new EventsWrapper(Events);
+        Utils.defineSoftGetter(this.Events, 'bind', () => this.plugin);
+
+        this._menuItems = undefined;
+        this._injectedStyles = undefined;
+        this._modalStack = undefined;
+    }
+
+    get plugin() {
+        return PluginManager.getPluginByPath(this.pluginPath);
+    }
+
+    async bridge(plugin_id) {
+        const plugin = await PluginManager.waitForPlugin(plugin_id);
+        return plugin.bridge;
+    }
+
+    get require() { return this.import }
+    import(m) {
+        const module = ExtModuleManager.findModule(m);
+        if (module && module.__require) return module.__require;
+        return null;
+    }
+
+    get Api() { return this }
+
+    get AsyncEventEmitter() { return AsyncEventEmitter }
+    get EventsWrapper() { return EventsWrapper }
+
+    get CommonComponents() { return CommonComponents }
+    get Components() { return Components }
+    get Filters() { return Filters }
+    get Discord() { return DiscordApi }
+    get DiscordApi() { return DiscordApi }
+    get ReactComponents() { return ReactComponents }
+    get ReactHelpers() { return ReactHelpers }
+    get Reflection() { return Reflection }
+    get DOM() { return DOM }
+    get VueInjector() { return VueInjector }
+
+    get observer() {
+        return this._observer || (this._observer = new DOMObserver());
+    }
+
+    /**
+     * Logger
+     */
+
+    get Logger() {
+        return {
+            log: (...message) => Logger.log(this.plugin.name, message),
+            error: (...message) => Logger.err(this.plugin.name, message),
+            err: (...message) => Logger.err(this.plugin.name, message),
+            warn: (...message) => Logger.warn(this.plugin.name, message),
+            info: (...message) => Logger.info(this.plugin.name, message),
+            debug: (...message) => Logger.dbg(this.plugin.name, message),
+            dbg: (...message) => Logger.dbg(this.plugin.name, message)
+        };
+    }
+
+    /**
+     * Utils
+     */
+
+    get Utils() {
+        return {
+            overload: (...args) => Utils.overload.apply(Utils, args),
+            tryParseJson: (...args) => Utils.tryParseJson.apply(Utils, args),
+            toCamelCase: (...args) => Utils.toCamelCase.apply(Utils, args),
+            compare: (...args) => Utils.compare.apply(Utils, args),
+            deepclone: (...args) => Utils.deepclone.apply(Utils, args),
+            deepfreeze: (...args) => Utils.deepfreeze.apply(Utils, args),
+            removeFromArray: (...args) => Utils.removeFromArray.apply(Utils, args),
+            defineSoftGetter: (...args) => Utils.defineSoftGetter.apply(Utils, args),
+            wait: (...args) => Utils.wait.apply(Utils, args),
+            until: (...args) => Utils.until.apply(Utils, args),
+            findInTree: (...args) => Utils.findInTree.apply(Utils, args),
+            findInReactTree: (...args) => Utils.findInReactTree.apply(Utils, args)
+        };
+    }
+
+    /**
+     * Settings
+     */
+
+    createSettingsSet(args, ...merge) {
+        return new SettingsSet(args || {}, ...merge);
+    }
+    createSettingsCategory(args, ...merge) {
+        return new SettingsCategory(args, ...merge);
+    }
+    createSetting(args, ...merge) {
+        return new Setting(args, ...merge);
+    }
+    createSettingsScheme(args) {
+        return new SettingsScheme(args);
+    }
+    get Settings() {
+        return {
+            createSet: this.createSettingsSet.bind(this),
+            createCategory: this.createSettingsCategory.bind(this),
+            createSetting: this.createSetting.bind(this),
+            createScheme: this.createSettingsScheme.bind(this)
+        };
+    }
+
+    /**
+     * InternalSettings
+     */
+
+    getInternalSetting(set, category, setting) {
+        return Settings.get(set, category, setting);
+    }
+    get InternalSettings() {
+        return {
+            get: this.getInternalSetting.bind(this)
+        };
+    }
+
+    /**
+     * BdMenu
+     */
+
+    get BdMenu() {
+        return {
+            open: BdMenu.open.bind(BdMenu),
+            close: BdMenu.close.bind(BdMenu),
+            items: this.BdMenuItems,
+            BdMenuItems: this.BdMenuItems
+        };
+    }
+
+    /**
+     * BdMenuItems
+     */
+
+    get menuItems() {
+        return this._menuItems || (this._menuItems = []);
+    }
+    addMenuItem(item) {
+        return BdMenu.items.add(item);
+    }
+    addMenuSettingsSet(category, set, text) {
+        const item = BdMenu.items.addSettingsSet(category, set, text);
+        return this.menuItems.push(item);
+    }
+    addMenuVueComponent(category, text, component) {
+        const item = BdMenu.items.addVueComponent(category, text, component);
+        return this.menuItems.push(item);
+    }
+    removeMenuItem(item) {
+        BdMenu.items.remove(item);
+        Utils.removeFromArray(this.menuItems, item);
+    }
+    removeAllMenuItems() {
+        for (const item of this.menuItems)
+            BdMenu.items.remove(item);
+    }
+    get BdMenuItems() {
+        return Object.defineProperty({
+            add: this.addMenuItem.bind(this),
+            addSettingsSet: this.addMenuSettingsSet.bind(this),
+            addVueComponent: this.addMenuVueComponent.bind(this),
+            remove: this.removeMenuItem.bind(this),
+            removeAll: this.removeAllMenuItems.bind(this)
+        }, 'items', {
+            get: () => this.menuItems
+        });
+    }
+
+    /**
+     * BdContextMenu
+     */
+
+    showContextMenu(event, groups) {
+        BdContextMenu.show(event, groups);
+        this.activeMenu.menu = BdContextMenu.activeMenu.menu;
+    }
+    get activeMenu() {
+        return this._activeMenu || (this._activeMenu = { menu: null });
+    }
+    get BdContextMenu() {
+        return Object.defineProperty({
+            show: this.showContextMenu.bind(this)
+        }, 'activeMenu', {
+            get: () => this.activeMenu
+        });
+    }
+
+    /**
+     * CssUtils
+     */
+
+    get injectedStyles() {
+        return this._injectedStyles || (this._injectedStyles = []);
+    }
+    compileSass(scss, options) {
+        return ClientIPC.send('bd-compileSass', Object.assign({ data: scss }, options));
+    }
+    getConfigAsSCSS(settingsset) {
+        return ThemeManager.getConfigAsSCSS(settingsset ? settingsset : this.plugin.settings);
+    }
+    getConfigAsSCSSMap(settingsset) {
+        return ThemeManager.getConfigAsSCSSMap(settingsset ? settingsset : this.plugin.settings);
+    }
+    injectStyle(id, css) {
+        if (id && !css) css = id, id = undefined;
+        this.deleteStyle(id);
+        const styleid = `plugin-${this.plugin.id}-${id}`;
+        this.injectedStyles.push(id);
+        DOM.injectStyle(css, styleid);
+    }
+    async injectSass(id, scss, options) {
+        // In most cases a plugin's styles should be precompiled instead of using this
+        if (id && !scss && !options) scss = id, id = undefined;
+        const css = (await this.compileSass(scss, options)).css.toString();
+        this.injectStyle(id, css, options);
+    }
+    deleteStyle(id) {
+        const styleid = `plugin-${this.plugin.id}-${id}`;
+        this.injectedStyles.splice(this.injectedStyles.indexOf(styleid), 1);
+        DOM.deleteStyle(styleid);
+    }
+    deleteAllStyles(id) {
+        for (const id of this.injectedStyles) {
+            this.deleteStyle(id);
+        }
+    }
+    get CssUtils() {
+        return {
+            compileSass: this.compileSass.bind(this),
+            getConfigAsSCSS: this.getConfigAsSCSS.bind(this),
+            getConfigAsSCSSMap: this.getConfigAsSCSSMap.bind(this),
+            injectStyle: this.injectStyle.bind(this),
+            injectSass: this.injectSass.bind(this),
+            deleteStyle: this.deleteStyle.bind(this),
+            deleteAllStyles: this.deleteAllStyles.bind(this)
+        };
+    }
+
+    /**
+     * Modals
+     */
+
+    get modalStack() {
+        return this._modalStack || (this._modalStack = []);
+    }
+    addModal(_modal, component) {
+        const modal = Modals.add(_modal, component);
+        modal.on('close', () => Utils.removeFromArray(this.modalStack, modal));
+        this.modalStack.push(modal);
+        return modal;
+    }
+    closeModal(modal, force) {
+        return Modals.close(modal, force);
+    }
+    closeAllModals(force) {
+        const promises = [];
+        for (const modal of this.modalStack)
+            promises.push(modal.close(force));
+        return Promise.all(promises);
+    }
+    closeLastModal(force) {
+        if (!this.modalStack.length) return;
+        return this.modalStack[this.modalStack.length - 1].close(force);
+    }
+    basicModal(title, text) {
+        return this.addModal(Modals.createBasicModal(title, text));
+    }
+    settingsModal(settingsset, headertext, options) {
+        return this.addModal(Modals.createSettingsModal(settingsset, headertext, options));
+    }
+    get Modals() {
+        return Object.defineProperties({
+            add: this.addModal.bind(this),
+            close: this.closeModal.bind(this),
+            closeAll: this.closeAllModals.bind(this),
+            closeLast: this.closeLastModal.bind(this),
+            basic: this.basicModal.bind(this),
+            settings: this.settingsModal.bind(this)
+        }, {
+            stack: {
+                get: () => this.modalStack
+            },
+            baseComponent: {
+                get: () => Modals.baseComponent
+            }
+        });
+    }
+
+    /**
+     * Toasts
+     */
+
+    showToast(message, options = {}) {
+        return Toasts.push(message, options);
+    }
+    showSuccessToast(message, options = {}) {
+        return Toasts.success(message, options);
+    }
+    showInfoToast(message, options = {}) {
+        return Toasts.info(message, options);
+    }
+    showErrorToast(message, options = {}) {
+        return Toasts.error(message, options);
+    }
+    showWarningToast(message, options = {}) {
+        return Toasts.warning(message, options);
+    }
+    get Toasts() {
+        return {
+            push: this.showToast.bind(this),
+            success: this.showSuccessToast.bind(this),
+            error: this.showErrorToast.bind(this),
+            info: this.showInfoToast.bind(this),
+            warning: this.showWarningToast.bind(this),
+            get enabled() { return Toasts.enabled }
+        };
+    }
+
+    /**
+     * Notifications
+     */
+
+    get notificationStack() {
+        return this._notificationStack || (this._notificationStack = []);
+    }
+    addNotification(title, text, buttons = []) {
+        if (arguments.length <= 1) text = title, title = undefined;
+        if (arguments[1] instanceof Array) [text, buttons] = arguments, title = undefined;
+
+        const notification = Notifications.add(title, text, buttons, () => Utils.removeFromArray(this.notificationStack, notification));
+        this.notificationStack.push(notification);
+        return notification;
+    }
+    dismissNotification(index) {
+        index = Notifications.stack.indexOf(this.notificationStack[index]);
+        if (index) Notifications.dismiss(index);
+    }
+    dismissAllNotifications() {
+        for (const index in this.notificationStack) {
+            this.dismissNotification(index);
+        }
+    }
+    get Notifications() {
+        return Object.defineProperty({
+            add: this.addNotification.bind(this),
+            dismiss: this.dismissNotification.bind(this),
+            dismissAll: this.dismissAllNotifications.bind(this)
+        }, 'stack', {
+            get: () => this.notificationStack
+        });
+    }
+
+    /**
+     * Autocomplete
+     */
+
+    get autocompleteSets() {
+        return this._autocompleteSets || (this._autocompleteSets = new Map());
+    }
+    addAutocompleteController(prefix, controller) {
+        if (!controller) controller = this.plugin;
+        if (GlobalAc.validPrefix(prefix)) return;
+        GlobalAc.add(prefix, controller);
+        this.autocompleteSets.set(prefix, controller);
+    }
+    removeAutocompleteController(prefix) {
+        if (this.autocompleteSets.get(prefix) !== GlobalAc.sets.get(prefix)) return;
+        GlobalAc.remove(prefix);
+        this.autocompleteSets.delete(prefix);
+    }
+    removeAllAutocompleteControllers() {
+        for (const [prefix] of this.autocompleteSets) {
+            this.removeAutocompleteController(prefix);
+        }
+    }
+    validAutocompletePrefix(prefix) {
+        return GlobalAc.validPrefix(prefix);
+    }
+    toggleAutocompleteMode(prefix, sterm) {
+        return GlobalAc.toggle(prefix, sterm);
+    }
+    searchAutocomplete(prefix, sterm) {
+        return GlobalAc.items(prefix, sterm);
+    }
+    get Autocomplete() {
+        return Object.defineProperty({
+            add: this.addAutocompleteController.bind(this),
+            remove: this.removeAutocompleteController.bind(this),
+            removeAll: this.removeAllAutocompleteControllers.bind(this),
+            validPrefix: this.validAutocompletePrefix.bind(this),
+            toggle: this.toggleAutocompleteMode.bind(this),
+            search: this.searchAutocomplete.bind(this)
+        }, 'sets', {
+            get: () => this.autocompleteSets
+        });
+    }
+
+    /**
+     * Emotes
+     */
+
+    get emotes() {
+        return EmoteModule.database;
+    }
+    get favouriteEmotes() {
+        return EmoteModule.favourites;
+    }
+    get mostUsedEmotes() {
+        return EmoteModule.mostUsed;
+    }
+    setFavouriteEmote(emote, favourite) {
+        return EmoteModule[favourite ? 'removeFavourite' : 'addFavourite'](emote);
+    }
+    addFavouriteEmote(emote) {
+        return EmoteModule.addFavourite(emote);
+    }
+    removeFavouriteEmote(emote) {
+        return EmoteModule.removeFavourite(emote);
+    }
+    isFavouriteEmote(emote) {
+        return EmoteModule.isFavourite(emote);
+    }
+    getEmote(emote) {
+        return EmoteModule.findByName(emote, true);
+    }
+    getEmoteUseCount(emote) {
+        const mostUsed = EmoteModule.mostUsed.find(mu => mu.key === emote.name);
+        return mostUsed ? mostUsed.useCount : 0;
+    }
+    incrementEmoteUseCount(emote) {
+        return EmoteModule.addToMostUsed(emote);
+    }
+    searchEmotes(regex, limit) {
+        return EmoteModule.search(regex, limit);
+    }
+    get Emotes() {
+        return Object.defineProperties({
+            setFavourite: this.setFavouriteEmote.bind(this),
+            addFavourite: this.addFavouriteEmote.bind(this),
+            removeFavourite: this.removeFavouriteEmote.bind(this),
+            isFavourite: this.isFavouriteEmote.bind(this),
+            getEmote: this.getEmote.bind(this),
+            getUseCount: this.getEmoteUseCount.bind(this),
+            incrementUseCount: this.incrementEmoteUseCount.bind(this),
+            search: this.searchEmotes.bind(this)
+        }, {
+            emotes: {
+                get: () => this.emotes
+            },
+            favourites: {
+                get: () => this.favouriteEmotes
+            },
+            mostused: {
+                get: () => this.mostUsedEmotes
+            }
+        });
+    }
+
+    /**
+     * Plugins
+     */
+
+    async getPlugin(plugin_id) {
+        // This should require extra permissions
+        return PluginManager.waitForPlugin(plugin_id);
+    }
+    listPlugins() {
+        return PluginManager.localContent.map(plugin => plugin.id);
+    }
+    get Plugins() {
+        return {
+            getPlugin: this.getPlugin.bind(this),
+            listPlugins: this.listPlugins.bind(this)
+        };
+    }
+
+    /**
+     * Themes
+     */
+
+    async getTheme(theme_id) {
+        // This should require extra permissions
+        return ThemeManager.waitForContent(theme_id);
+    }
+    listThemes() {
+        return ThemeManager.localContent.map(theme => theme.id);
+    }
+    get Themes() {
+        return {
+            getTheme: this.getTheme.bind(this),
+            listThemes: this.listThemes.bind(this)
+        };
+    }
+
+    /**
+     * ExtModules
+     */
+
+    async getModule(module_id) {
+        // This should require extra permissions
+        return ExtModuleManager.waitForContent(module_id);
+    }
+    listModules() {
+        return ExtModuleManager.localContent.map(module => module.id);
+    }
+    get ExtModules() {
+        return {
+            getModule: this.getModule.bind(this),
+            listModules: this.listModules.bind(this)
+        };
+    }
+
+    /**
+     * Patcher
+     */
+
+    get patches() {
+        return Patcher.getPatchesByCaller(this.plugin.id);
+    }
+    patchBefore(...args) { return this.pushChildPatch(...args, 'before') }
+    patchAfter(...args) { return this.pushChildPatch(...args, 'after') }
+    patchInstead(...args) { return this.pushChildPatch(...args, 'instead') }
+    pushChildPatch(...args) {
+        return Patcher.pushChildPatch(this.plugin.id, ...args);
+    }
+    unpatchAll(patches) {
+        return Patcher.unpatchAll(patches || this.plugin.id);
+    }
+    get Patcher() {
+        return Object.defineProperty({
+            before: this.patchBefore.bind(this),
+            after: this.patchAfter.bind(this),
+            instead: this.patchInstead.bind(this),
+            pushChildPatch: this.pushChildPatch.bind(this),
+            unpatchAll: this.unpatchAll.bind(this),
+            monkeyPatch: this.monkeyPatch.bind(this)
+        }, 'patches', {
+            get: () => this.patches
+        });
+    }
+    get monkeyPatch() {
+        return m => MonkeyPatch(this.plugin.id, m);
+    }
+
+    /**
+     * DiscordContextMenu
+     */
+
+    get discordContextMenus() {
+        return this._discordContextMenus || (this._discordContextMenus = []);
+    }
+    addDiscordContextMenu(items, filter) {
+        const menu = DiscordContextMenu.add(items, filter);
+        this.discordContextMenus.push(menu);
+        return menu;
+    }
+    removeDiscordContextMenu(menu) {
+        DiscordContextMenu.remove(menu);
+        Utils.removeFromArray(this.discordContextMenus, menu);
+    }
+    removeAllDiscordContextMenus() {
+        for (const menu of this.discordContextMenus) {
+            this.removeDiscordContextMenu(menu);
+        }
+    }
+    get DiscordContextMenu() {
+        return Object.defineProperty({
+            add: this.addDiscordContextMenu.bind(this),
+            remove: this.removeDiscordContextMenu.bind(this),
+            removeAll: this.removeAllDiscordContextMenus.bind(this)
+        }, 'menus', {
+            get: () => this.discordContextMenus
+        });
+    }
+
+    Vuewrap(id, component, props) {
+        return VueInjector.createReactElement(Vue.component(id, component), props);
+    }
+
+}
+
+// Stop plugins from modifying the plugin API for all plugins
+// Plugins can still modify their own plugin API object
+Object.freeze(PluginApi);
+Object.freeze(PluginApi.prototype);

client/src/modules/pluginmanager.js

@@ -8,10 +8,16 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-import ContentManager from './contentmanager';
-import Plugin from './plugin';
+import { Permissions } from 'modules';
+import { Modals } from 'ui';
+import { ErrorEvent } from 'structs';
 import { ClientLogger as Logger } from 'common';
-import { Events } from 'modules';
+import Globals from './globals';
+import ContentManager from './contentmanager';
+import ExtModuleManager from './extmodulemanager';
+import Plugin from './plugin';
+import PluginApi from './pluginapi';
+import Vendor from './vendor';
 
 export default class extends ContentManager {
 
@@ -24,70 +30,132 @@ export default class extends ContentManager {
     }
 
     static get moduleName() {
-        return 'PluginManager';
+        return 'Plugin Manager';
     }
 
     static get pathId() {
         return 'plugins';
     }
 
-    static get loadAllPlugins() { return this.loadAllContent }
+    static async loadAllPlugins(suppressErrors) {
+        this.loaded = false;
+        const loadAll = await this.loadAllContent(true);
+        this.loaded = true;
+        for (const plugin of this.localPlugins) {
+            if (!plugin.enabled) continue;
+            plugin.userConfig.enabled = false;
+
+            try {
+                plugin.start(false);
+            } catch (err) {
+                // Disable the plugin but don't save it - the next time BetterDiscord is started the plugin will attempt to start again
+                this.errors.push(new ErrorEvent({
+                    module: this.moduleName,
+                    message: `Failed to start ${plugin.name}`,
+                    err
+                }));
+
+                Logger.err(this.moduleName, [`Failed to start plugin ${plugin.name}:`, err]);
+            }
+        }
+
+        if (this.errors.length && !suppressErrors) {
+            Modals.error({
+                header: `${this.moduleName} - ${this.errors.length} ${this.contentType}${this.errors.length !== 1 ? 's' : ''} failed to load`,
+                module: this.moduleName,
+                type: 'err',
+                content: this.errors
+            });
+            this._errors = [];
+        }
+
+        return loadAll;
+    }
     static get refreshPlugins() { return this.refreshContent }
 
     static get loadContent() { return this.loadPlugin }
-    static async loadPlugin(paths, configs, info, main) {
-        const plugin = window.require(paths.mainPath)(Plugin, {}, {});
-        const instance = new plugin({ configs, info, main, paths: { contentPath: paths.contentPath, dirName: paths.dirName } });
+    static async loadPlugin(paths, configs, info, main, dependencies, permissions, mainExport, packed = false) {
+        if (permissions && permissions.length > 0) {
+            for (const perm of permissions) {
+                Logger.log(this.moduleName, `Permission: ${Permissions.permissionText(perm).HEADER} - ${Permissions.permissionText(perm).BODY}`);
+            }
+            try {
+                const allowed = await Modals.permissions(`${info.name} wants to:`, info.name, permissions).promise;
+            } catch (err) {
+                return;
+            }
+        }
 
-        if (instance.enabled) instance.start();
+        const deps = {};
+        if (dependencies) {
+            for (const [key, value] of Object.entries(dependencies)) {
+                const extModule = ExtModuleManager.findModule(key);
+                if (!extModule) {
+                    throw {message: `Dependency ${key}:${value} is not loaded.`};
+                }
+                deps[key] = extModule.__require;
+            }
+        }
+
+        const pluginExports = Globals.require(paths.mainPath);
+
+        const pluginFunction = mainExport ? pluginExports[mainExport]
+            : pluginExports.__esModule ? pluginExports.default : pluginExports;
+        if (typeof pluginFunction !== 'function')
+            throw {message: `Plugin ${info.name} did not export a function.`};
+
+        const plugin = pluginFunction.call(pluginExports, Plugin, new PluginApi(info, paths.contentPath), Vendor, deps);
+        if (!plugin || !(plugin.prototype instanceof Plugin))
+            throw {message: `Plugin ${info.name} did not return a class that extends Plugin.`};
+
+        const instance = new plugin({
+            configs, info, main, paths
+        });
+
+        if (instance.enabled && this.loaded) {
+            instance.userConfig.enabled = false;
+            instance.start(false);
+        }
         return instance;
     }
 
-    static get unloadContent() { return this.unloadPlugin }
-    static async unloadPlugin(plugin) {
-        try {
-            if (plugin.enabled) plugin.stop();
-            const { pluginPath } = plugin;
-            const index = this.getPluginIndex(plugin);
+    static get deletePlugin() { return this.deleteContent }
+    static get unloadPlugin() { return this.unloadContent }
+    static get reloadPlugin() { return this.reloadContent }
 
-            delete window.require.cache[window.require.resolve(pluginPath)];
-            this.localPlugins.splice(index, 1);
-        } catch (err) {
-            //This might fail but we don't have any other option at this point
-            Logger.err('PluginManager', err);
+    static unloadContentHook(content, reload) {
+        delete Globals.require.cache[Globals.require.resolve(content.paths.mainPath)];
+        const uncache = [];
+        for (const required in Globals.require.cache) {
+            if (!required.includes(content.paths.contentPath)) continue;
+            uncache.push(Globals.require.resolve(required));
         }
+        for (const u of uncache) delete Globals.require.cache[u];
     }
 
-    static async reloadPlugin(plugin) {
-        const _plugin = plugin instanceof Plugin ? plugin : this.findPlugin(plugin);
-        if (!_plugin) throw { 'message': 'Attempted to reload a plugin that is not loaded?' };
-        if (!_plugin.stop()) throw { 'message': 'Plugin failed to stop!' };
-        const index = this.getPluginIndex(_plugin);
-        const { pluginPath, dirName } = _plugin;
-
-        delete window.require.cache[window.require.resolve(pluginPath)];
-
-        return this.preloadContent(dirName, true, index);
+    /**
+     * Stops a plugin.
+     * @param {Plugin|String} plugin
+     * @return {Promise}
+     */
+    static stopPlugin(plugin) {
+        plugin = this.isPlugin(plugin) ? plugin : this.getPluginById(plugin);
+        return plugin.stop();
     }
 
-    static stopPlugin(name) {
-        const plugin = name instanceof Plugin ? name : this.getPluginByName(name);
-        try {
-            if (plugin) return plugin.stop();
-        } catch (err) {
-           // Logger.err('PluginManager', err);
-        }
-        return true; //Return true anyways since plugin doesn't exist
+    /**
+     * Starts a plugin.
+     * @param {Plugin|String} plugin
+     * @return {Promise}
+     */
+    static startPlugin(plugin) {
+        plugin = this.isPlugin(plugin) ? plugin : this.getPluginById(plugin);
+        return plugin.start();
     }
 
-    static startPlugin(name) {
-        const plugin = name instanceof Plugin ? name : this.getPluginByName(name);
-        try {
-            if (plugin) return plugin.start();
-        } catch (err) {
-           // Logger.err('PluginManager', err);
-        }
-        return true; //Return true anyways since plugin doesn't exist
+    static get isPlugin() { return this.isThisContent }
+    static isThisContent(plugin) {
+        return plugin instanceof Plugin;
     }
 
     static get findPlugin() { return this.findContent }
@@ -97,4 +165,6 @@ export default class extends ContentManager {
     static get getPluginByPath() { return this.getContentByPath }
     static get getPluginByDirName() { return this.getContentByDirName }
 
+    static get waitForPlugin() { return this.waitForContent }
+
 }

client/src/modules/reactcomponents.js

@@ -0,0 +1,586 @@
+/**
+ * BetterDiscord React Component Manipulations
+ * Original concept and some code by samogot - https://github.com/samogot / https://github.com/samogot/betterdiscord-plugins/tree/master/v2/1Lib%20Discord%20Internals
+ *
+ * Copyright (c) 2015-present JsSucks - https://github.com/JsSucks
+ * All rights reserved.
+ * https://github.com/JsSucks - https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { DOM, Modals } from 'ui';
+import { Utils, Filters, ClientLogger as Logger } from 'common';
+import { MonkeyPatch } from './patcher';
+import Reflection from './reflection/index';
+import DiscordApi from './discordapi';
+import PackageInstaller from './packageinstaller';
+
+class Helpers {
+    static get plannedActions() {
+        return this._plannedActions || (this._plannedActions = new Map());
+    }
+
+    static recursiveArray(parent, key, count = 1) {
+        let index = 0;
+        function* innerCall(parent, key) {
+            const item = parent[key];
+            if (item instanceof Array) {
+                for (const subKey of item.keys()) {
+                    yield* innerCall(item, subKey)
+                }
+                return;
+            }
+            yield { item, parent, key, index: index++, count };
+        }
+
+        return innerCall(parent, key);
+    }
+
+    static recursiveArrayCount(parent, key) {
+        let count = 0;
+        // eslint-disable-next-line no-empty-pattern
+        for (let {} of this.recursiveArray(parent, key))
+            ++count;
+        return this.recursiveArray(parent, key, count);
+    }
+
+    static get recursiveChildren() {
+        return function* (parent, key, index = 0, count = 1) {
+            const item = parent[key];
+            yield { item, parent, key, index, count };
+            if (item && item.props && item.props.children) {
+                for (const { parent, key, index, count } of this.recursiveArrayCount(item.props, 'children')) {
+                    yield* this.recursiveChildren(parent, key, index, count);
+                }
+            }
+        }
+    }
+
+    static returnFirst(iterator, process) {
+        for (const child of iterator) {
+            const retVal = process(child);
+            if (retVal !== undefined) return retVal;
+        }
+    }
+
+    static getFirstChild(rootParent, rootKey, selector) {
+        const getDirectChild = (item, selector) => {
+            if (item && item.props && item.props.children) {
+                return this.returnFirst(this.recursiveArrayCount(item.props, 'children'), checkFilter.bind(null, selector));
+            }
+        };
+        const checkFilter = (selector, { item, parent, key, count, index }) => {
+            let match = true;
+            if (match && selector.type)
+                match = item && selector.type === item.type;
+            if (match && selector.tag)
+                match = item && typeof item.type === 'string' && selector.tag === item.type;
+            if (match && selector.className) {
+                match = item && item.props && typeof item.props.className === 'string';
+                if (match) {
+                    const classes = item.props.className.split(' ');
+                    if (selector.className === true)
+                        match = !!classes[0];
+                    else if (typeof selector.className === 'string')
+                        match = classes.includes(selector.className);
+                    else if (selector.className instanceof RegExp)
+                        match = !!classes.find(cls => selector.className.test(cls));
+                    else match = false;
+                }
+            }
+            if (match && selector.text) {
+                if (selector.text === true)
+                    match = typeof item === 'string';
+                else if (typeof selector.text === 'string')
+                    match = item === selector.text;
+                else if (selector.text instanceof RegExp)
+                    match = typeof item === 'string' && selector.text.test(item);
+                else match = false;
+            }
+            if (match && selector.nthChild)
+                match = index === (selector.nthChild < 0 ? count + selector.nthChild : selector.nthChild);
+            if (match && selector.hasChild)
+                match = getDirectChild(item, selector.hasChild);
+            if (match && selector.hasSuccessor)
+                match = item && !!this.getFirstChild(parent, key, selector.hasSuccessor).item;
+            if (match && selector.eq) {
+                --selector.eq;
+                return;
+            }
+            if (match) {
+                if (selector.child) {
+                    return getDirectChild(item, selector.child);
+                } else if (selector.successor) {
+                    return this.getFirstChild(parent, key, selector.successor);
+                }
+
+                return { item, parent, key };
+            }
+        };
+        return this.returnFirst(this.recursiveChildren(rootParent, rootKey), checkFilter.bind(null, selector)) || {};
+    }
+
+    static parseSelector(selector) {
+        if (selector.startsWith('.')) return { className: selector.substr(1) }
+        if (selector.startsWith('#')) return { id: selector.substr(1) }
+        return {}
+    }
+
+    static findByProp(obj, what, value) {
+        if (obj.hasOwnProperty(what) && obj[what] === value) return obj;
+        if (obj.props && !obj.children) return this.findByProp(obj.props, what, value);
+        if (!obj.children) return null;
+        if (!(obj.children instanceof Array)) return this.findByProp(obj.children, what, value);
+        for (const child of obj.children) {
+            if (!child) continue;
+            const findInChild = this.findByProp(child, what, value);
+            if (findInChild) return findInChild;
+        }
+        return null;
+    }
+
+    static findProp(obj, what) {
+        if (obj.hasOwnProperty(what)) return obj[what];
+        if (obj.props && !obj.children) return this.findProp(obj.props, what);
+        if (!obj.children) return null;
+        if (!(obj.children instanceof Array)) return this.findProp(obj.children, what);
+        for (const child of obj.children) {
+            if (!child) continue;
+            const findInChild = this.findProp(child, what);
+            if (findInChild) return findInChild;
+        }
+        return null;
+    }
+
+    static get React() {
+        return Reflection.modules.React;
+    }
+
+    static get ReactDOM() {
+        return Reflection.modules.ReactDOM;
+    }
+}
+
+export { Helpers as ReactHelpers };
+
+class ReactComponent {
+    constructor(id, component, retVal, important) {
+        this.id = id;
+        this.component = component;
+        this.retVal = retVal;
+        this.important = important;
+    }
+
+    get elements() {
+        if (!this.important || !this.important.selector) return [];
+
+        return document.querySelectorAll(this.important.selector);
+    }
+
+    get stateNodes() {
+        return [...this.elements].map(e => Reflection.DOM(e).getComponentStateNode(this));
+    }
+
+    forceUpdateAll() {
+        for (const e of this.elements) {
+            Reflection.DOM(e).forceUpdate(this);
+        }
+    }
+}
+
+export class ReactComponents {
+    static get components() { return this._components || (this._components = []) }
+    static get unknownComponents() { return this._unknownComponents || (this._unknownComponents = []) }
+    static get listeners() { return this._listeners || (this._listeners = []) }
+    static get nameSetters() { return this._nameSetters || (this._nameSetters = []) }
+    static get componentAliases() { return this._componentAliases || (this._componentAliases = []) }
+
+    static get ReactComponent() { return ReactComponent }
+
+    static push(component, retVal, important) {
+        if (!(component instanceof Function)) return null;
+        const { displayName } = component;
+        if (!displayName) {
+            return this.processUnknown(component, retVal);
+        }
+
+        const have = this.components.find(comp => comp.id === displayName);
+        if (have) {
+            if (!have.important) have.important = important;
+            return component;
+        }
+
+        const c = new ReactComponent(displayName, component, retVal, important);
+        this.components.push(c);
+
+        const listener = this.listeners.find(listener => listener.id === displayName);
+        if (listener) {
+            for (const l of listener.listeners) l(c);
+            Utils.removeFromArray(this.listeners, listener);
+        }
+
+        return c;
+    }
+
+    /**
+     * Finds a component from the components array or by waiting for it to be mounted.
+     * @param {String} name The component's name
+     * @param {Object} important An object containing a selector to look for
+     * @param {Function} filter A function to filter components if a single element is rendered by multiple components
+     * @return {Promise => ReactComponent}
+     */
+    static async getComponent(name, important, filter) {
+        name = this.getComponentName(name);
+
+        const have = this.components.find(c => c.id === name);
+        if (have) return have;
+
+        if (important) {
+            const callback = () => {
+                if (this.components.find(c => c.id === name)) {
+                    Logger.info('ReactComponents', `Important component ${name} already found`);
+                    DOM.observer.unsubscribe(observerSubscription);
+                    return;
+                }
+
+                const elements = document.querySelectorAll(important.selector);
+                if (!elements.length) return;
+
+                let component, reflect;
+                for (const element of elements) {
+                    reflect = Reflection.DOM(element);
+                    component = filter ? reflect.components.find(component => {
+                        try {
+                            return filter.call(undefined, component);
+                        } catch (err) {
+                            return false;
+                        }
+                    }) : reflect.component;
+                    if (component) break;
+                }
+
+                if (!component && filter) {
+                    Logger.log('ReactComponents', ['Found elements matching the query selector but no components passed the filter']);
+                    return;
+                }
+
+                DOM.observer.unsubscribe(observerSubscription);
+
+                if (!component) {
+                    Logger.err('ReactComponents', [`FAILED TO GET IMPORTANT COMPONENT ${name} WITH REFLECTION FROM`, elements]);
+                    return;
+                }
+
+                if (!component.displayName) component.displayName = name;
+                Logger.info('ReactComponents', [`Found important component ${name} with reflection`, reflect]);
+                important.filter = filter;
+                this.push(component, undefined, important);
+            };
+
+            const observerSubscription = DOM.observer.subscribeToQuerySelector(callback, important.selector, null, true);
+            setTimeout(callback, 0);
+        }
+
+        let listener = this.listeners.find(l => l.id === name);
+        if (!listener) this.listeners.push(listener = {
+            id: name,
+            listeners: []
+        });
+
+        return new Promise(resolve => {
+            listener.listeners.push(resolve);
+        });
+    }
+
+    static getComponentName(name) {
+        const resolvedAliases = [];
+
+        while (this.componentAliases[name]) {
+            resolvedAliases.push(name);
+            name = this.componentAliases[name];
+
+            if (resolvedAliases.includes(name)) break;
+        }
+
+        return name;
+    }
+
+    static setName(name, filter) {
+        const have = this.components.find(c => c.id === name);
+        if (have) return have;
+
+        for (const [rci, rc] of this.unknownComponents.entries()) {
+            if (filter(rc.component)) {
+                rc.component.displayName = name;
+                this.unknownComponents.splice(rci, 1);
+                return this.push(rc.component);
+            }
+        }
+        return this.nameSetters.push({ name, filter });
+    }
+
+    static processUnknown(component, retVal) {
+        const have = this.unknownComponents.find(c => c.component === component);
+        for (const [fi, filter] of this.nameSetters.entries()) {
+            if (filter.filter.filter(component)) {
+                Logger.log('ReactComponents', 'Filter match!');
+                component.displayName = filter.name;
+                this.nameSetters.splice(fi, 1);
+                return this.push(component, retVal);
+            }
+        }
+        if (have) return have;
+        this.unknownComponents.push(component);
+        return component;
+    }
+}
+
+export class ReactAutoPatcher {
+    /**
+     * Wait for React to be loaded and patch it's createElement to store all unknown components.
+     * Also patches some known components.
+     */
+    static async autoPatch() {
+        const React = await Reflection.module.waitForModuleByName('React');
+
+        this.unpatchCreateElement = MonkeyPatch('BD:ReactComponents:createElement', React).before('createElement', (component, args) => ReactComponents.push(args[0]));
+
+        this.patchComponents();
+    }
+
+    /**
+     * Patches a few known components.
+     */
+    static patchComponents() {
+        const componentPatchFunctions = Object.getOwnPropertyNames(this).filter(p => p.startsWith('patch') && p !== 'patchComponents');
+        return Promise.all(componentPatchFunctions.map(p => this[p].call(this)));
+    }
+
+    static async patchMessage() {
+        const { selector } = Reflection.resolve('message', 'messageCozy', 'messageCompact');
+        this.Message = await ReactComponents.getComponent('Message', {selector}, m => m.prototype && m.prototype.renderCozy);
+
+        this.unpatchMessageRender = MonkeyPatch('BD:ReactComponents', this.Message.component.prototype).after('render', (component, args, retVal) => {
+            const { message, jumpSequenceId, canFlash } = component.props;
+            const { id, colorString, bot, author, attachments, embeds } = message;
+            if (jumpSequenceId && canFlash) retVal = retVal.props.children;
+            retVal.props['data-message-id'] = id;
+            retVal.props['data-colourstring'] = colorString;
+            if (author && author.id) retVal.props['data-user-id'] = author.id;
+            if (bot || (author && author.bot)) retVal.props.className += ' bd-isBot';
+            if (attachments && attachments.length) retVal.props.className += ' bd-hasAttachments';
+            if (embeds && embeds.length) retVal.props.className += ' bd-hasEmbeds';
+            if (author && author.id === DiscordApi.currentUser.id) retVal.props.className += ' bd-isCurrentUser';
+
+            const dapiMessage = DiscordApi.Message.from(message);
+            if (dapiMessage.guild && author.id === dapiMessage.guild.ownerId) retVal.props.className += ' bd-isGuildOwner';
+            if (dapiMessage.guild && dapiMessage.guild.isMember(author.id)) retVal.props.className += ' bd-isGuildMember';
+        });
+
+        this.Message.forceUpdateAll();
+    }
+
+    static async patchMessageContent() {
+        const { selector } = Reflection.resolve('container', 'containerCozy', 'containerCompact', 'edited');
+        this.MessageContent = await ReactComponents.getComponent('MessageContent', {selector}, c => c.defaultProps && c.defaultProps.hasOwnProperty('disableButtons'));
+    }
+
+    static async patchSpoiler() {
+        const { selector } = Reflection.resolve('spoilerText', 'spoilerContainer');
+        this.Spoiler = await ReactComponents.getComponent('Spoiler', {selector}, c => c.prototype.renderSpoilerText);
+    }
+
+    static async patchMessageAccessories() {
+        const { selector } = Reflection.resolve('container', 'containerCozy', 'embedWrapper');
+        this.MessageAccessories = await ReactComponents.getComponent('MessageAccessories', {selector});
+    }
+
+    static async patchMessageGroup() {
+        const { selector } = Reflection.resolve('container', 'message', 'messageCozy');
+        this.MessageGroup = await ReactComponents.getComponent('MessageGroup', {selector});
+
+        this.unpatchMessageGroupRender = MonkeyPatch('BD:ReactComponents', this.MessageGroup.component.prototype).after('render', (component, args, retVal) => {
+            const { author, type } = component.props.messages[0];
+            retVal.props['data-author-id'] = author.id;
+            if (author.id === DiscordApi.currentUser.id) retVal.props.className += ' bd-isCurrentUser';
+            if (type !== 0) retVal.props.className += ' bd-isSystemMessage';
+
+            const dapiMessage = DiscordApi.Message.from(component.props.messages[0]);
+            if (dapiMessage.guild && author.id === dapiMessage.guild.ownerId) retVal.props.className += ' bd-isGuildOwner';
+            if (dapiMessage.guild && dapiMessage.guild.isMember(author.id)) retVal.props.className += ' bd-isGuildMember';
+        });
+
+        this.MessageGroup.forceUpdateAll();
+    }
+
+    static async patchImageWrapper() {
+        ReactComponents.componentAliases.ImageWrapper = 'Image';
+
+        const { selector } = Reflection.resolve('imageWrapper');
+        this.ImageWrapper = await ReactComponents.getComponent('ImageWrapper', {selector}, c => typeof c.defaultProps.children === 'function');
+    }
+
+    static async patchChannelMember() {
+        ReactComponents.componentAliases.ChannelMember = 'MemberListItem';
+
+        const { selector } = Reflection.resolve('member', 'memberInner', 'activity');
+        this.ChannelMember = await ReactComponents.getComponent('ChannelMember', {selector}, m => m.prototype.renderActivity);
+
+        this.unpatchChannelMemberRender = MonkeyPatch('BD:ReactComponents', this.ChannelMember.component.prototype).after('render', (component, args, retVal) => {
+            if (!retVal.props || !retVal.props.children) return;
+            const user = Helpers.findProp(component, 'user');
+            if (!user) return;
+            retVal.props['data-user-id'] = user.id;
+            retVal.props['data-colourstring'] = component.props.colorString;
+            if (component.props.isOwner) retVal.props.className += ' bd-isGuildOwner';
+        });
+
+        this.ChannelMember.forceUpdateAll();
+    }
+
+    static async patchNameTag() {
+        const { selector } = Reflection.resolve('nameTag', 'username', 'discriminator', 'ownerIcon');
+        this.NameTag = await ReactComponents.getComponent('NameTag', {selector});
+    }
+
+    static async patchGuild() {
+        const selector = `div.${Reflection.resolve('container', 'guildIcon', 'selected', 'unread').className}:not(:first-child)`;
+        this.Guild = await ReactComponents.getComponent('Guild', {selector}, m => m.prototype.renderBadge);
+
+        this.unpatchGuild = MonkeyPatch('BD:ReactComponents', this.Guild.component.prototype).after('render', (component, args, retVal) => {
+            const { guild } = component.props;
+            if (!guild) return;
+            retVal.props['data-guild-id'] = guild.id;
+            retVal.props['data-guild-name'] = guild.name;
+        });
+
+        this.Guild.forceUpdateAll();
+    }
+
+    /**
+     * The Channel component contains the header, message scroller, message form and member list.
+     */
+    static async patchChannel() {
+        const { selector } = Reflection.resolve('chat', 'title', 'channelName');
+        this.Channel = await ReactComponents.getComponent('Channel', {selector});
+
+        this.unpatchChannel = MonkeyPatch('BD:ReactComponents', this.Channel.component.prototype).after('render', (component, args, retVal) => {
+            const channel = component.props.channel || component.state.channel;
+            if (!channel) return;
+            retVal.props['data-channel-id'] = channel.id;
+            retVal.props['data-channel-name'] = channel.name;
+            if ([0, 2, 4].includes(channel.type)) retVal.props.className += ' bd-isGuildChannel';
+            if ([1, 3].includes(channel.type)) retVal.props.className += ' bd-isPrivateChannel';
+            if (channel.type === 3) retVal.props.className += ' bd-isGroupChannel';
+        });
+
+        this.Channel.forceUpdateAll();
+    }
+
+    static async patchChannelTextArea() {
+        const { selector } = Reflection.resolve('channelTextArea', 'autocomplete');
+        this.ChannelTextArea = await ReactComponents.getComponent('ChannelTextArea', {selector});
+    }
+
+    /**
+     * The GuildTextChannel component represents a text channel in the guild channel list.
+     */
+    static async patchGuildTextChannel() {
+        ReactComponents.componentAliases.GuildTextChannel = 'TextChannel';
+
+        const { selector } = Reflection.resolve('containerDefault', 'actionIcon');
+        this.GuildTextChannel = await ReactComponents.getComponent('GuildTextChannel', {selector}, c => c.prototype.renderMentionBadge);
+
+        this.unpatchGuildTextChannel = MonkeyPatch('BD:ReactComponents', this.GuildTextChannel.component.prototype).after('render', this._afterChannelRender);
+
+        this.GuildTextChannel.forceUpdateAll();
+    }
+
+    /**
+     * The GuildVoiceChannel component represents a voice channel in the guild channel list.
+     */
+    static async patchGuildVoiceChannel() {
+        ReactComponents.componentAliases.GuildVoiceChannel = 'VoiceChannel';
+
+        const { selector } = Reflection.resolve('containerDefault', 'actionIcon');
+        this.GuildVoiceChannel = await ReactComponents.getComponent('GuildVoiceChannel', {selector}, c => c.prototype.handleVoiceConnect);
+
+        this.unpatchGuildVoiceChannel = MonkeyPatch('BD:ReactComponents', this.GuildVoiceChannel.component.prototype).after('render', this._afterChannelRender);
+
+        this.GuildVoiceChannel.forceUpdateAll();
+    }
+
+    /**
+     * The DirectMessage component represents a channel in the direct messages list.
+     */
+    static async patchDirectMessage() {
+        ReactComponents.componentAliases.DirectMessage = 'PrivateChannel';
+
+        const { selector } = Reflection.resolve('channel', 'avatar', 'name');
+        this.DirectMessage = await ReactComponents.getComponent('DirectMessage', {selector}, c => c.prototype.renderAvatar);
+
+        this.unpatchDirectMessage = MonkeyPatch('BD:ReactComponents', this.DirectMessage.component.prototype).after('render', this._afterChannelRender);
+
+        this.DirectMessage.forceUpdateAll();
+    }
+
+    static _afterChannelRender(component, args, retVal) {
+        const { channel } = component.props;
+        if (!channel) return;
+
+        retVal.props['data-channel-id'] = channel.id;
+        retVal.props['data-channel-name'] = channel.name;
+        if ([0, 2, 4].includes(channel.type)) retVal.props.className += ' bd-isGuildChannel';
+        if (channel.type === 2) retVal.props.className += ' bd-isVoiceChannel';
+        // if (channel.type === 4) retVal.props.className += ' bd-isChannelCategory';
+        if ([1, 3].includes(channel.type)) retVal.props.className += ' bd-isPrivateChannel';
+        if (channel.type === 3) retVal.props.className += ' bd-isGroupChannel';
+    }
+
+    static async patchUserProfileModal() {
+        ReactComponents.componentAliases.UserProfileModal = 'UserProfileBody';
+
+        const { selector } = Reflection.resolve('root', 'topSectionNormal');
+        this.UserProfileModal = await ReactComponents.getComponent('UserProfileModal', {selector}, c => c.prototype.renderHeader && c.prototype.renderBadges);
+
+        this.unpatchUserProfileModal = MonkeyPatch('BD:ReactComponents', this.UserProfileModal.component.prototype).after('render', (component, args, retVal) => {
+            const root = retVal.props.children[0] || retVal.props.children;
+            const { user } = component.props;
+            if (!user) return;
+            root.props['data-user-id'] = user.id;
+            if (user.bot) root.props.className += ' bd-isBot';
+            if (user.id === DiscordApi.currentUser.id) root.props.className += ' bd-isCurrentUser';
+        });
+
+        this.UserProfileModal.forceUpdateAll();
+    }
+
+    static async patchUserPopout() {
+        const { selector } = Reflection.resolve('userPopout', 'headerNormal');
+        this.UserPopout = await ReactComponents.getComponent('UserPopout', {selector}, c => c.prototype.renderHeader);
+
+        this.unpatchUserPopout = MonkeyPatch('BD:ReactComponents', this.UserPopout.component.prototype).after('render', (component, args, retVal) => {
+            const root = retVal.props.children[0] || retVal.props.children;
+            const { user, guild, guildMember } = component.props;
+            if (!user) return;
+            root.props['data-user-id'] = user.id;
+            if (user.bot) root.props.className += ' bd-isBot';
+            if (user.id === DiscordApi.currentUser.id) root.props.className += ' bd-isCurrentUser';
+            if (guild) root.props['data-guild-id'] = guild.id;
+            if (guild && user.id === guild.ownerId) root.props.className += ' bd-isGuildOwner';
+            if (guild && guildMember) root.props.className += ' bd-isGuildMember';
+            if (guildMember && guildMember.roles.length) root.props.className += ' bd-hasRoles';
+        });
+
+        this.UserPopout.forceUpdateAll();
+    }
+
+    static async patchUploadArea() {
+        const { selector } = Reflection.resolve('uploadArea');
+        this.UploadArea = await ReactComponents.getComponent('UploadArea', {selector});
+
+        PackageInstaller.uploadAreaPatch(this.UploadArea);
+    }
+}

client/src/modules/reflection/index.js

@@ -0,0 +1,44 @@
+/**
+ * BetterDiscord Reflection Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Module, Modules } from './modules';
+import { Reflection as DOM } from 'ui';
+import Resolver from './resolver';
+
+export default class Reflection {
+
+    static get module() {
+        return Module;
+    }
+
+    static get modules() {
+        return Modules;
+    }
+
+    static get resolve() {
+        return Resolver.resolve;
+    }
+
+    static get resolveAsync() {
+        return Resolver.resolveAsync;
+    }
+
+    static get resolver() {
+        return Resolver;
+    }
+
+    static get DOM() {
+        return DOM;
+    }
+
+    static get require() {
+        return Module.require;
+    }
+}

client/src/modules/reflection/modules.js

@@ -0,0 +1,433 @@
+/**
+ * BetterDiscord Reflection Modules
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Utils, Filters } from 'common';
+import Events from '../events';
+
+const KnownModules = {
+    React: Filters.byProperties(['createElement', 'cloneElement']),
+    ReactDOM: Filters.byProperties(['render', 'findDOMNode']),
+
+    Events: Filters.byPrototypeFields(['setMaxListeners', 'emit']),
+
+    /* Guild Info, Stores, and Utilities */
+    GuildStore: Filters.byProperties(['getGuild']),
+    SortedGuildStore: Filters.byProperties(['getSortedGuilds']),
+    SelectedGuildStore: Filters.byProperties(['getLastSelectedGuildId']),
+    GuildSync: Filters.byProperties(['getSyncedGuilds']),
+    GuildInfo: Filters.byProperties(['getAcronym']),
+    GuildChannelsStore: Filters.byProperties(['getChannels', 'getDefaultChannel']),
+    GuildMemberStore: Filters.byProperties(['getMember']),
+    MemberCountStore: Filters.byProperties(['getMemberCounts']),
+    GuildEmojiStore: Filters.byProperties(['getEmojis']),
+    GuildActions: Filters.byProperties(['markGuildAsRead']),
+    GuildPermissions: Filters.byProperties(['getGuildPermissions']),
+
+    /* Channel Store & Actions */
+    ChannelStore: Filters.byProperties(['getChannels', 'getDMFromUserId']),
+    SelectedChannelStore: Filters.byProperties(['getLastSelectedChannelId']),
+    ChannelActions: Filters.byProperties(['selectChannel']),
+    PrivateChannelActions: Filters.byProperties(['openPrivateChannel']),
+    ChannelSelector: Filters.byProperties(['selectGuild', 'selectChannel']),
+    VoiceChannelActions: Filters.byProperties(['selectVoiceChannel']),
+
+    /* Current User Info, State and Settings */
+    UserInfoStore: Filters.byProperties(['getToken']),
+    UserSettingsStore: Filters.byProperties(['guildPositions']),
+    AccountManager: Filters.byProperties(['register', 'login']),
+    UserSettingsUpdater: Filters.byProperties(['updateRemoteSettings']),
+    OnlineWatcher: Filters.byProperties(['isOnline']),
+    CurrentUserIdle: Filters.byProperties(['getIdleTime']),
+    RelationshipStore: Filters.byProperties(['isBlocked', 'isFriend']),
+    RelationshipManager: Filters.byProperties(['addRelationship']),
+    MentionStore: Filters.byProperties(['getMentions']),
+
+    /* User Stores and Utils */
+    UserStore: Filters.byProperties(['getCurrentUser']),
+    UserStatusStore: Filters.byProperties(['getStatuses']),
+    UserTypingStore: Filters.byProperties(['isTyping']),
+    UserActivityStore: Filters.byProperties(['getActivity']),
+    UserNameResolver: Filters.byProperties(['getName']),
+    UserNoteStore: Filters.byProperties(['getNote']),
+    UserNoteActions: Filters.byProperties(['updateNote']),
+    DraftActions: Filters.byProperties(['changeDraft']),
+
+    /* Emoji Store and Utils */
+    EmojiInfo: Filters.byProperties(['isEmojiDisabled']),
+    EmojiUtils: Filters.byProperties(['getGuildEmoji']),
+    EmojiStore: Filters.byProperties(['getByCategory', 'EMOJI_NAME_RE']),
+
+    /* Invite Store and Utils */
+    InviteStore: Filters.byProperties(['getInvites']),
+    InviteResolver: Filters.byProperties(['findInvite']),
+    InviteActions: Filters.byProperties(['acceptInvite']),
+
+    /* Discord Objects & Utils */
+    DiscordConstants: Filters.byProperties(['Permissions', 'ActivityTypes', 'StatusTypes']),
+    Permissions: Filters.byProperties(['getHighestRole']),
+    ColorConverter: Filters.byProperties(['hex2int']),
+    ColorShader: Filters.byProperties(['darken']),
+    TinyColor: Filters.byPrototypeFields(['toRgb']),
+    ClassResolver: Filters.byProperties(['getClass']),
+    ButtonData: Filters.byProperties(['ButtonSizes']),
+    IconNames: Filters.byProperties(['IconNames']),
+    NavigationUtils: Filters.byProperties(['transitionTo', 'replaceWith', 'getHistory']),
+
+    /* Discord Messages */
+    MessageStore: Filters.byProperties(['getMessages']),
+    MessageActions: Filters.byProperties(['jumpToMessage', '_sendMessage']),
+    MessageQueue: Filters.byProperties(['enqueue']),
+    MessageParser: Filters.byProperties(['createMessage', 'parse', 'unparse']),
+
+    /* In-Game Overlay */
+    OverlayUserPopoutSettings: Filters.byProperties(['openUserPopout']),
+    OverlayUserPopoutInfo: Filters.byProperties(['getOpenedUserPopout']),
+
+    /* Experiments */
+    ExperimentStore: Filters.byProperties(['getExperimentOverrides']),
+    ExperimentsManager: Filters.byProperties(['isDeveloper']),
+    CurrentExperiment: Filters.byProperties(['getExperimentId']),
+
+    /* Images, Avatars and Utils */
+    ImageResolver: Filters.byProperties(['getUserAvatarURL']),
+    ImageUtils: Filters.byProperties(['getSizedImageSrc']),
+    AvatarDefaults: Filters.byProperties(['getUserAvatarURL', 'DEFAULT_AVATARS']),
+
+    /* Drag & Drop */
+    DNDActions: Filters.byProperties(['beginDrag']),
+    DNDSources: Filters.byProperties(['addTarget']),
+    DNDObjects: Filters.byProperties(['DragSource']),
+
+    /* Electron & Other Internals with Utils */
+    ElectronModule: Filters.byProperties(['_getMainWindow']),
+    Dispatcher: Filters.byProperties(['dirtyDispatch']),
+    PathUtils: Filters.byProperties(['hasBasename']),
+    NotificationModule: Filters.byProperties(['showNotification']),
+    RouterModule: Filters.byProperties(['Router']),
+    APIModule: Filters.byProperties(['getAPIBaseURL']),
+    AnalyticEvents: Filters.byProperties(['AnalyticEventConfigs']),
+    KeyGenerator: Filters.byCode(/"binary"/),
+    Buffers: Filters.byProperties(['Buffer', 'kMaxLength']),
+    DeviceStore: Filters.byProperties(['getDevices']),
+    SoftwareInfo: Filters.byProperties(['os']),
+    CurrentContext: Filters.byProperties(['setTagsContext']),
+
+    /* Media Stuff (Audio/Video) */
+    MediaDeviceInfo: Filters.byProperties(['Codecs', 'SUPPORTED_BROWSERS']),
+    MediaInfo: Filters.byProperties(['getOutputVolume']),
+    MediaEngineInfo: Filters.byProperties(['MediaEngineFeatures']),
+    VoiceInfo: Filters.byProperties(['EchoCancellation']),
+    VideoStream: Filters.byProperties(['getVideoStream']),
+    SoundModule: Filters.byProperties(['playSound']),
+
+    /* Window, DOM, HTML */
+    WindowInfo: Filters.byProperties(['isFocused', 'windowSize']),
+    TagInfo: Filters.byProperties(['VALID_TAG_NAMES']),
+    DOMInfo: Filters.byProperties(['canUseDOM']),
+
+    /* Locale/Location and Time */
+    LocaleManager: Filters.byProperties(['setLocale']),
+    Moment: Filters.byProperties(['parseZone']),
+    LocationManager: Filters.byProperties(['createLocation']),
+    Timestamps: Filters.byProperties(['fromTimestamp']),
+    TimeFormatter: Filters.byProperties(['dateFormat']),
+
+    /* Strings and Utils */
+    Strings: Filters.byProperties(['TEXT', 'TEXTAREA_PLACEHOLDER']),
+    StringFormats: Filters.byProperties(['a', 'z']),
+    StringUtils: Filters.byProperties(['toASCII']),
+
+    /* URLs and Utils */
+    URLParser: Filters.byProperties(['Url', 'parse']),
+    ExtraURLs: Filters.byProperties(['getArticleURL']),
+
+    /* Text Processing */
+    hljs: Filters.byProperties(['highlight', 'highlightBlock']),
+    SimpleMarkdown: Filters.byProperties(['parseBlock', 'parseInline', 'defaultOutput']),
+
+    /* DOM/React Components */
+    /* ==================== */
+    LayerManager: Filters.byProperties(['popLayer', 'pushLayer']),
+    UserSettingsWindow: Filters.byProperties(['open', 'updateAccount']),
+    ChannelSettingsWindow: Filters.byProperties(['open', 'updateChannel']),
+    GuildSettingsWindow: Filters.byProperties(['open', 'updateGuild']),
+
+    /* Modals */
+    ModalStack: Filters.byProperties(['push', 'update', 'pop', 'popWithKey']),
+    ConfirmModal: Filters.byPrototypeFields(['handleCancel', 'handleSubmit', 'handleMinorConfirm']),
+    UserProfileModal: Filters.byProperties(['fetchMutualFriends', 'setSection']),
+    ChangeNicknameModal: Filters.byProperties(['open', 'changeNickname']),
+    CreateChannelModal: Filters.byProperties(['open', 'createChannel']),
+    PruneMembersModal: Filters.byProperties(['open', 'prune']),
+    NotificationSettingsModal: Filters.byProperties(['open', 'updateNotificationSettings']),
+    PrivacySettingsModal: Filters.byCode(/PRIVACY_SETTINGS_MODAL_OPEN/, m => m.open),
+    CreateInviteModal: Filters.byProperties(['open', 'createInvite']),
+
+    /* Popouts */
+    PopoutStack: Filters.byProperties(['open', 'close', 'closeAll']),
+    PopoutOpener: Filters.byProperties(['openPopout']),
+    EmojiPicker: Filters.byPrototypeFields(['onHoverEmoji', 'selectEmoji']),
+
+    /* Context Menus */
+    ContextMenuActions: Filters.byCode(/CONTEXT_MENU_CLOSE/, c => c.close),
+    ContextMenuItemsGroup: Filters.byCode(/itemGroup/),
+    ContextMenuItem: Filters.byCode(/\.label\b.*\.hint\b.*\.action\b/),
+
+    /* In-Message Links */
+    ExternalLink: Filters.byCode(/\.trusted\b/)
+};
+
+class Module {
+
+    /**
+     * Finds a module using a filter function.
+     * @param {Function} filter A function to use to filter modules
+     * @param {Boolean} first Whether to return only the first matching module
+     * @param {Array} modules An array of modules to search in
+     * @return {Any}
+     */
+    static getModule(filter, first = true, _modules) {
+        const modules = _modules || this.getAllModules();
+        const rm = [];
+        for (const index in modules) {
+            if (!modules.hasOwnProperty(index)) continue;
+            const module = modules[index];
+            const { exports } = module;
+            let foundModule = null;
+
+            if (!exports) continue;
+            if (exports.__esModule && exports.default && filter(exports.default)) foundModule = exports.default;
+            if (filter(exports)) foundModule = exports;
+            if (!foundModule) continue;
+            if (first) return foundModule;
+            rm.push(foundModule);
+        }
+        return first ? undefined : rm;
+    }
+
+    /**
+     * Finds a module by it's name.
+     * @param {String} name The name of the module
+     * @param {Function} fallback A function to use to filter modules if not finding a known module
+     * @return {Any}
+     */
+    static byName(name, fallback) {
+        if (Cache.hasOwnProperty(name)) return Cache[name];
+        if (KnownModules.hasOwnProperty(name)) fallback = KnownModules[name];
+        if (!fallback) return undefined;
+        const module = this.getModule(fallback, true);
+        return module ? Cache[name] = module : undefined;
+    }
+
+    /**
+     * Finds a module by it's display name.
+     * @param {String} name The display name of the module
+     * @return {Any}
+     */
+    static byDisplayName(name) {
+        return this.getModule(Filters.byDisplayName(name), true);
+    }
+
+    /**
+     * Finds a module using it's code.
+     * @param {RegEx} regex A regular expression to use to filter modules
+     * @param {Boolean} first Whether to return the only the first matching module
+     * @return {Any}
+     */
+    static byRegex(regex, first = true) {
+        return this.getModule(Filters.byCode(regex), first);
+    }
+
+    /**
+     * Finds the first module using properties on it's prototype.
+     * @param {any} props Properties to use to filter modules
+     * @return {Any}
+     */
+    static byPrototypes(...prototypes) {
+        return this.getModule(Filters.byPrototypeFields(prototypes), true);
+    }
+
+    /**
+     * Finds all modules using properties on it's prototype.
+     * @param {any} props Properties to use to filter modules
+     * @return {Any}
+     */
+    static allByPrototypes(...prototypes) {
+        return this.getModule(Filters.byPrototypeFields(prototypes), false);
+    }
+
+    /**
+     * Finds the first module using it's own properties.
+     * @param {any} props Properties to use to filter modules
+     * @return {Any}
+     */
+    static byProps(...props) {
+        return this.getModule(Filters.byProperties(props), true);
+    }
+
+    /**
+     * Finds all modules using it's own properties.
+     * @param {any} props Properties to use to filter modules
+     * @return {Any}
+     */
+    static allByProps(...props) {
+        return this.getModule(Filters.byProperties(props), false);
+    }
+
+    /**
+     * Discord's __webpack_require__ function.
+     */
+    static get require() {
+        if (this._require) return this._require;
+
+        const __webpack_require__ = this.getWebpackRequire();
+        if (!__webpack_require__) return null;
+
+        this.hookWebpackRequireCache(__webpack_require__);
+        return this._require = __webpack_require__;
+    }
+
+    static getWebpackRequire() {
+        const id = 'bd-webpackmodules';
+
+        if (typeof window.webpackJsonp === 'function') {
+            const __webpack_require__ = window['webpackJsonp']([], {
+                [id]: (module, exports, __webpack_require__) => exports.default = __webpack_require__
+            }, [id]).default;
+            delete __webpack_require__.m[id];
+            delete __webpack_require__.c[id];
+            return __webpack_require__;
+        } else if (window.webpackJsonp && window.webpackJsonp.push) {
+            const __webpack_require__ = window['webpackJsonp'].push([[], {
+                [id]: (module, exports, req) => exports.default = req
+            }, [[id]]]).default;
+            window['webpackJsonp'].pop();
+            delete __webpack_require__.m[id];
+            delete __webpack_require__.c[id];
+            return __webpack_require__;
+        }
+    }
+
+    static hookWebpackRequireCache(__webpack_require__) {
+        __webpack_require__.c = new Proxy(__webpack_require__.c, {
+            set(module_cache, module_id, module) {
+                // Add it to our emitter cache and emit a module-loading event
+                this.moduleLoading(module_id, module);
+                Events.emit('module-loading', module);
+
+                // Add the module to the cache as normal
+                module_cache[module_id] = module;
+            }
+        });
+    }
+
+    static moduleLoading(module_id, module) {
+        if (this.require.c[module_id]) return;
+
+        if (!this.moduleLoadedEventTimeout) {
+            this.moduleLoadedEventTimeout = setTimeout(() => {
+                this.moduleLoadedEventTimeout = undefined;
+
+                // Emit a module-loaded event for every module
+                for (const module of this.modulesLoadingCache) {
+                    Events.emit('module-loaded', module);
+                }
+
+                // Emit a modules-loaded event
+                Events.emit('modules-loaded', this.modulesLoadingCache);
+
+                this.modulesLoadedCache = [];
+            }, 0);
+        }
+
+        // Add this to our own cache
+        if (!this.modulesLoadingCache) this.modulesLoadingCache = [];
+        this.modulesLoadingCache.push(module);
+    }
+
+    static waitForWebpackRequire() {
+        return Utils.until(() => this.require, 10);
+    }
+
+    /**
+     * Waits for a module to load.
+     * This only returns a single module, as it can't guarentee there are no more modules that could
+     * match the filter, which is pretty much what that would be asking for.
+     * @param {Function} filter The name of a known module or a filter function
+     * @return {Any}
+     */
+    static async waitForModule(filter) {
+        const module = this.getModule(filter);
+        if (module) return module;
+
+        while (this.require.m.length > this.require.c.length) {
+            const additionalModules = await Events.once('modules-loaded');
+
+            const module = this.getModule(filter, true, additionalModules);
+            if (module) return module;
+        }
+
+        throw new Error('All modules have now been loaded. None match the passed filter.');
+    }
+
+    /**
+     * Finds a module by it's name.
+     * @param {String} name The name of the module
+     * @param {Function} fallback A function to use to filter modules if not finding a known module
+     * @return {Any}
+     */
+    static async waitForModuleByName(name, fallback) {
+        if (Cache.hasOwnProperty(name)) return Cache[name];
+        if (KnownModules.hasOwnProperty(name)) fallback = KnownModules[name];
+        if (!fallback) return undefined;
+        const module = await this.waitForModule(fallback, true);
+        return module ? Cache[name] = module : undefined;
+    }
+
+    static waitForModuleByDisplayName(props) {
+        return this.waitForModule(Filters.byDisplayName(props));
+    }
+    static waitForModuleByRegex(props) {
+        return this.waitForModule(Filters.byCode(props));
+    }
+    static waitForModuleByProps(props) {
+        return this.waitForModule(Filters.byProperties(props));
+    }
+    static waitForModuleByPrototypes(props) {
+        return this.waitForModule(Filters.byPrototypeFields(props));
+    }
+
+    /**
+     * Returns all loaded modules.
+     * @return {Array}
+     */
+    static getAllModules() {
+        return this.require.c;
+    }
+
+    /**
+     * Returns an array of known modules.
+     * @return {Array}
+     */
+    static listKnownModules() {
+        return Object.keys(KnownModules);
+    }
+
+    static get KnownModules() { return KnownModules }
+
+}
+
+const Modules = new Proxy(Module, {
+    get(Module, name) {
+        return Module.byName(name);
+    }
+});
+
+export { Module, Modules }

client/src/modules/reflection/resolver.js

@@ -0,0 +1,59 @@
+/**
+ * BetterDiscord Reflection Resolver
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Module } from './modules';
+
+class Resolved {
+
+    constructor(module, ...classes) {
+        this.module = Module.byProps(...classes);
+        this.classes = classes;
+    }
+
+    get className() {
+        return this.module && this.module[this.classes[0]] ? this.module[this.classes[0]].split(' ')[0] : this.classes[0];
+    }
+
+    get selector() {
+        return `.${this.className}`;
+    }
+
+}
+
+export default class Resolver {
+
+    static resolve(...classes) {
+        return new Resolved(Module.byProps(...classes), ...classes);
+    }
+
+    static async resolveAsync(...classes) {
+        const module = await Module.waitForModuleByProps([...classes]);
+        return new Resolved(module, ...classes);
+    }
+
+    /**
+     * Searches for a class module and returns a class from it.
+     * @param {String} base The first part of the class to find
+     * @param {String} ...additional_classes Additional classes to look for to filter duplicate class modules
+     * @return {String}
+     */
+    static getClassName(base, ...additional_classes) {
+        const class_module = Module.byProps([base, ...additional_classes]);
+        if (class_module && class_module[base]) return class_module[base].split(' ')[0];
+    }
+    static async waitForClassName(base, ...additional_classes) {
+        const class_module = await Module.waitForModuleByProps([base, ...additional_classes]);
+        if (class_module && class_module[base]) return class_module[base].split(' ')[0];
+    }
+    static getSelector(base, ...additional_classes) {
+        const gcn = this.getClassName(base, ...additional_classes);
+        if (gcn) return `.${gcn}`;
+    }
+}

client/src/modules/reflection/wpm.depr.js

@@ -0,0 +1,430 @@
+/**
+ * BetterDiscord WebpackModules Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Utils, Filters } from 'common';
+import Events from '../events';
+
+const KnownModules = {
+    React: Filters.byProperties(['createElement', 'cloneElement']),
+    ReactDOM: Filters.byProperties(['render', 'findDOMNode']),
+
+    Events: Filters.byPrototypeFields(['setMaxListeners', 'emit']),
+
+    /* Guild Info, Stores, and Utilities */
+    GuildStore: Filters.byProperties(['getGuild']),
+    SortedGuildStore: Filters.byProperties(['getSortedGuilds']),
+    SelectedGuildStore: Filters.byProperties(['getLastSelectedGuildId']),
+    GuildSync: Filters.byProperties(['getSyncedGuilds']),
+    GuildInfo: Filters.byProperties(['getAcronym']),
+    GuildChannelsStore: Filters.byProperties(['getChannels', 'getDefaultChannel']),
+    GuildMemberStore: Filters.byProperties(['getMember']),
+    MemberCountStore: Filters.byProperties(['getMemberCounts']),
+    GuildEmojiStore: Filters.byProperties(['getEmojis']),
+    GuildActions: Filters.byProperties(['markGuildAsRead']),
+    GuildPermissions: Filters.byProperties(['getGuildPermissions']),
+
+    /* Channel Store & Actions */
+    ChannelStore: Filters.byProperties(['getChannels', 'getDMFromUserId']),
+    SelectedChannelStore: Filters.byProperties(['getLastSelectedChannelId']),
+    ChannelActions: Filters.byProperties(['selectChannel']),
+    PrivateChannelActions: Filters.byProperties(['openPrivateChannel']),
+    ChannelSelector: Filters.byProperties(['selectGuild', 'selectChannel']),
+    VoiceChannelActions: Filters.byProperties(['selectVoiceChannel']),
+
+    /* Current User Info, State and Settings */
+    UserInfoStore: Filters.byProperties(['getToken']),
+    UserSettingsStore: Filters.byProperties(['guildPositions']),
+    AccountManager: Filters.byProperties(['register', 'login']),
+    UserSettingsUpdater: Filters.byProperties(['updateRemoteSettings']),
+    OnlineWatcher: Filters.byProperties(['isOnline']),
+    CurrentUserIdle: Filters.byProperties(['getIdleTime']),
+    RelationshipStore: Filters.byProperties(['isBlocked', 'isFriend']),
+    RelationshipManager: Filters.byProperties(['addRelationship']),
+    MentionStore: Filters.byProperties(['getMentions']),
+
+    /* User Stores and Utils */
+    UserStore: Filters.byProperties(['getCurrentUser']),
+    UserStatusStore: Filters.byProperties(['getStatuses']),
+    UserTypingStore: Filters.byProperties(['isTyping']),
+    UserActivityStore: Filters.byProperties(['getActivity']),
+    UserNameResolver: Filters.byProperties(['getName']),
+    UserNoteStore: Filters.byProperties(['getNote']),
+    UserNoteActions: Filters.byProperties(['updateNote']),
+    DraftActions: Filters.byProperties(['changeDraft']),
+
+    /* Emoji Store and Utils */
+    EmojiInfo: Filters.byProperties(['isEmojiDisabled']),
+    EmojiUtils: Filters.byProperties(['getGuildEmoji']),
+    EmojiStore: Filters.byProperties(['getByCategory', 'EMOJI_NAME_RE']),
+
+    /* Invite Store and Utils */
+    InviteStore: Filters.byProperties(['getInvites']),
+    InviteResolver: Filters.byProperties(['findInvite']),
+    InviteActions: Filters.byProperties(['acceptInvite']),
+
+    /* Discord Objects & Utils */
+    DiscordConstants: Filters.byProperties(['Permissions', 'ActivityTypes', 'StatusTypes']),
+    Permissions: Filters.byProperties(['getHighestRole']),
+    ColorConverter: Filters.byProperties(['hex2int']),
+    ColorShader: Filters.byProperties(['darken']),
+    TinyColor: Filters.byPrototypeFields(['toRgb']),
+    ClassResolver: Filters.byProperties(['getClass']),
+    ButtonData: Filters.byProperties(['ButtonSizes']),
+    IconNames: Filters.byProperties(['IconNames']),
+    NavigationUtils: Filters.byProperties(['transitionTo', 'replaceWith', 'getHistory']),
+
+    /* Discord Messages */
+    MessageStore: Filters.byProperties(['getMessages']),
+    MessageActions: Filters.byProperties(['jumpToMessage', '_sendMessage']),
+    MessageQueue: Filters.byProperties(['enqueue']),
+    MessageParser: Filters.byProperties(['createMessage', 'parse', 'unparse']),
+
+    /* In-Game Overlay */
+    OverlayUserPopoutSettings: Filters.byProperties(['openUserPopout']),
+    OverlayUserPopoutInfo: Filters.byProperties(['getOpenedUserPopout']),
+
+    /* Experiments */
+    ExperimentStore: Filters.byProperties(['getExperimentOverrides']),
+    ExperimentsManager: Filters.byProperties(['isDeveloper']),
+    CurrentExperiment: Filters.byProperties(['getExperimentId']),
+
+    /* Images, Avatars and Utils */
+    ImageResolver: Filters.byProperties(['getUserAvatarURL']),
+    ImageUtils: Filters.byProperties(['getSizedImageSrc']),
+    AvatarDefaults: Filters.byProperties(['getUserAvatarURL', 'DEFAULT_AVATARS']),
+
+    /* Drag & Drop */
+    DNDActions: Filters.byProperties(['beginDrag']),
+    DNDSources: Filters.byProperties(['addTarget']),
+    DNDObjects: Filters.byProperties(['DragSource']),
+
+    /* Electron & Other Internals with Utils */
+    ElectronModule: Filters.byProperties(['_getMainWindow']),
+    Dispatcher: Filters.byProperties(['dirtyDispatch']),
+    PathUtils: Filters.byProperties(['hasBasename']),
+    NotificationModule: Filters.byProperties(['showNotification']),
+    RouterModule: Filters.byProperties(['Router']),
+    APIModule: Filters.byProperties(['getAPIBaseURL']),
+    AnalyticEvents: Filters.byProperties(['AnalyticEventConfigs']),
+    KeyGenerator: Filters.byCode(/"binary"/),
+    Buffers: Filters.byProperties(['Buffer', 'kMaxLength']),
+    DeviceStore: Filters.byProperties(['getDevices']),
+    SoftwareInfo: Filters.byProperties(['os']),
+    CurrentContext: Filters.byProperties(['setTagsContext']),
+
+    /* Media Stuff (Audio/Video) */
+    MediaDeviceInfo: Filters.byProperties(['Codecs', 'SUPPORTED_BROWSERS']),
+    MediaInfo: Filters.byProperties(['getOutputVolume']),
+    MediaEngineInfo: Filters.byProperties(['MediaEngineFeatures']),
+    VoiceInfo: Filters.byProperties(['EchoCancellation']),
+    VideoStream: Filters.byProperties(['getVideoStream']),
+    SoundModule: Filters.byProperties(['playSound']),
+
+    /* Window, DOM, HTML */
+    WindowInfo: Filters.byProperties(['isFocused', 'windowSize']),
+    TagInfo: Filters.byProperties(['VALID_TAG_NAMES']),
+    DOMInfo: Filters.byProperties(['canUseDOM']),
+
+    /* Locale/Location and Time */
+    LocaleManager: Filters.byProperties(['setLocale']),
+    Moment: Filters.byProperties(['parseZone']),
+    LocationManager: Filters.byProperties(['createLocation']),
+    Timestamps: Filters.byProperties(['fromTimestamp']),
+    TimeFormatter: Filters.byProperties(['dateFormat']),
+
+    /* Strings and Utils */
+    Strings: Filters.byProperties(['TEXT', 'TEXTAREA_PLACEHOLDER']),
+    StringFormats: Filters.byProperties(['a', 'z']),
+    StringUtils: Filters.byProperties(['toASCII']),
+
+    /* URLs and Utils */
+    URLParser: Filters.byProperties(['Url', 'parse']),
+    ExtraURLs: Filters.byProperties(['getArticleURL']),
+
+    /* Text Processing */
+    hljs: Filters.byProperties(['highlight', 'highlightBlock']),
+    SimpleMarkdown: Filters.byProperties(['parseBlock', 'parseInline', 'defaultOutput']),
+
+    /* DOM/React Components */
+    /* ==================== */
+    LayerManager: Filters.byProperties(['popLayer', 'pushLayer']),
+    UserSettingsWindow: Filters.byProperties(['open', 'updateAccount']),
+    ChannelSettingsWindow: Filters.byProperties(['open', 'updateChannel']),
+    GuildSettingsWindow: Filters.byProperties(['open', 'updateGuild']),
+
+    /* Modals */
+    ModalStack: Filters.byProperties(['push', 'update', 'pop', 'popWithKey']),
+    ConfirmModal: Filters.byPrototypeFields(['handleCancel', 'handleSubmit', 'handleMinorConfirm']),
+    UserProfileModal: Filters.byProperties(['fetchMutualFriends', 'setSection']),
+    ChangeNicknameModal: Filters.byProperties(['open', 'changeNickname']),
+    CreateChannelModal: Filters.byProperties(['open', 'createChannel']),
+    PruneMembersModal: Filters.byProperties(['open', 'prune']),
+    NotificationSettingsModal: Filters.byProperties(['open', 'updateNotificationSettings']),
+    PrivacySettingsModal: Filters.byCode(/PRIVACY_SETTINGS_MODAL_OPEN/, m => m.open),
+    CreateInviteModal: Filters.byProperties(['open', 'createInvite']),
+
+    /* Popouts */
+    PopoutStack: Filters.byProperties(['open', 'close', 'closeAll']),
+    PopoutOpener: Filters.byProperties(['openPopout']),
+    EmojiPicker: Filters.byPrototypeFields(['onHoverEmoji', 'selectEmoji']),
+
+    /* Context Menus */
+    ContextMenuActions: Filters.byCode(/CONTEXT_MENU_CLOSE/, c => c.close),
+    ContextMenuItemsGroup: Filters.byCode(/itemGroup/),
+    ContextMenuItem: Filters.byCode(/\.label\b.*\.hint\b.*\.action\b/),
+
+    /* In-Message Links */
+    ExternalLink: Filters.byCode(/\.trusted\b/)
+};
+
+class WebpackModules {
+
+    /**
+     * Finds a module using a filter function.
+     * @param {Function} filter A function to use to filter modules
+     * @param {Boolean} first Whether to return only the first matching module
+     * @param {Array} modules An array of modules to search in
+     * @return {Any}
+     */
+    static getModule(filter, first = true, _modules) {
+        const modules = _modules || this.getAllModules();
+        const rm = [];
+        for (const index in modules) {
+            if (!modules.hasOwnProperty(index)) continue;
+            const module = modules[index];
+            const { exports } = module;
+            let foundModule = null;
+
+            if (!exports) continue;
+            if (exports.__esModule && exports.default && filter(exports.default)) foundModule = exports.default;
+            if (filter(exports)) foundModule = exports;
+            if (!foundModule) continue;
+            if (first) return foundModule;
+            rm.push(foundModule);
+        }
+        return first ? undefined : rm;
+    }
+
+    /**
+     * Finds a module by it's name.
+     * @param {String} name The name of the module
+     * @param {Function} fallback A function to use to filter modules if not finding a known module
+     * @return {Any}
+     */
+    static getModuleByName(name, fallback) {
+        if (Cache.hasOwnProperty(name)) return Cache[name];
+        if (KnownModules.hasOwnProperty(name)) fallback = KnownModules[name];
+        if (!fallback) return undefined;
+        const module = this.getModule(fallback, true);
+        return module ? Cache[name] = module : undefined;
+    }
+
+    /**
+     * Finds a module by it's display name.
+     * @param {String} name The display name of the module
+     * @return {Any}
+     */
+    static getModuleByDisplayName(name) {
+        return this.getModule(Filters.byDisplayName(name), true);
+    }
+
+    /**
+     * Finds a module using it's code.
+     * @param {RegEx} regex A regular expression to use to filter modules
+     * @param {Boolean} first Whether to return the only the first matching module
+     * @return {Any}
+     */
+    static getModuleByRegex(regex, first = true) {
+        return this.getModule(Filters.byCode(regex), first);
+    }
+
+    /**
+     * Finds a module using properties on it's prototype.
+     * @param {Array} props Properties to use to filter modules
+     * @param {Boolean} first Whether to return only the first matching module
+     * @return {Any}
+     */
+    static getModuleByPrototypes(prototypes, first = true) {
+        return this.getModule(Filters.byPrototypeFields(prototypes), first);
+    }
+
+    /**
+     * Finds a module using it's own properties.
+     * @param {Array} props Properties to use to filter modules
+     * @param {Boolean} first Whether to return only the first matching module
+     * @return {Any}
+     */
+    static getModuleByProps(props, first = true) {
+        return this.getModule(Filters.byProperties(props), first);
+    }
+
+    /**
+     * Discord's __webpack_require__ function.
+     */
+    static get require() {
+        if (this._require) return this._require;
+
+        const __webpack_require__ = this.getWebpackRequire();
+        if (!__webpack_require__) return null;
+
+        this.hookWebpackRequireCache(__webpack_require__);
+        return this._require = __webpack_require__;
+    }
+
+    static getWebpackRequire() {
+        const id = 'bd-webpackmodules';
+
+        if (typeof window.webpackJsonp === 'function') {
+            const __webpack_require__ = window['webpackJsonp']([], {
+                [id]: (module, exports, __webpack_require__) => exports.default = __webpack_require__
+            }, [id]).default;
+            delete __webpack_require__.m[id];
+            delete __webpack_require__.c[id];
+            return __webpack_require__;
+        } else if (window.webpackJsonp && window.webpackJsonp.push) {
+            const __webpack_require__ = window['webpackJsonp'].push([[], {
+                [id]: (module, exports, req) => exports.default = req
+            }, [[id]]]).default;
+            window['webpackJsonp'].pop();
+            delete __webpack_require__.m[id];
+            delete __webpack_require__.c[id];
+            return __webpack_require__;
+        }
+    }
+
+    static hookWebpackRequireCache(__webpack_require__) {
+        __webpack_require__.c = new Proxy(__webpack_require__.c, {
+            set(module_cache, module_id, module) {
+                // Add it to our emitter cache and emit a module-loading event
+                this.moduleLoading(module_id, module);
+                Events.emit('module-loading', module);
+
+                // Add the module to the cache as normal
+                module_cache[module_id] = module;
+            }
+        });
+    }
+
+    static moduleLoading(module_id, module) {
+        if (this.require.c[module_id]) return;
+
+        if (!this.moduleLoadedEventTimeout) {
+            this.moduleLoadedEventTimeout = setTimeout(() => {
+                this.moduleLoadedEventTimeout = undefined;
+
+                // Emit a module-loaded event for every module
+                for (const module of this.modulesLoadingCache) {
+                    Events.emit('module-loaded', module);
+                }
+
+                // Emit a modules-loaded event
+                Events.emit('modules-loaded', this.modulesLoadingCache);
+
+                this.modulesLoadedCache = [];
+            }, 0);
+        }
+
+        // Add this to our own cache
+        if (!this.modulesLoadingCache) this.modulesLoadingCache = [];
+        this.modulesLoadingCache.push(module);
+    }
+
+    static waitForWebpackRequire() {
+        return Utils.until(() => this.require, 10);
+    }
+
+    /**
+     * Waits for a module to load.
+     * This only returns a single module, as it can't guarentee there are no more modules that could
+     * match the filter, which is pretty much what that would be asking for.
+     * @param {Function} filter The name of a known module or a filter function
+     * @return {Any}
+     */
+    static async waitForModule(filter) {
+        const module = this.getModule(filter);
+        if (module) return module;
+
+        while (this.require.m.length > this.require.c.length) {
+            const additionalModules = await Events.once('modules-loaded');
+
+            const module = this.getModule(filter, true, additionalModules);
+            if (module) return module;
+        }
+
+        throw new Error('All modules have now been loaded. None match the passed filter.');
+    }
+
+    /**
+     * Finds a module by it's name.
+     * @param {String} name The name of the module
+     * @param {Function} fallback A function to use to filter modules if not finding a known module
+     * @return {Any}
+     */
+    static async waitForModuleByName(name, fallback) {
+        if (Cache.hasOwnProperty(name)) return Cache[name];
+        if (KnownModules.hasOwnProperty(name)) fallback = KnownModules[name];
+        if (!fallback) return undefined;
+        const module = await this.waitForModule(fallback, true);
+        return module ? Cache[name] = module : undefined;
+    }
+
+    static waitForModuleByDisplayName(props) {
+        return this.waitForModule(Filters.byDisplayName(props));
+    }
+    static waitForModuleByRegex(props) {
+        return this.waitForModule(Filters.byCode(props));
+    }
+    static waitForModuleByProps(props) {
+        return this.waitForModule(Filters.byProperties(props));
+    }
+    static waitForModuleByPrototypes(props) {
+        return this.waitForModule(Filters.byPrototypeFields(props));
+    }
+
+    /**
+     * Searches for a class module and returns a class from it.
+     * @param {String} base The first part of the class to find
+     * @param {String} ...additional_classes Additional classes to look for to filter duplicate class modules
+     * @return {String}
+     */
+    static getClassName(base, ...additional_classes) {
+        const class_module = this.getModuleByProps([base, ...additional_classes]);
+        if (class_module && class_module[base]) return class_module[base].split(' ')[0];
+    }
+    static async waitForClassName(base, ...additional_classes) {
+        const class_module = await this.waitForModuleByProps([base, ...additional_classes]);
+        if (class_module && class_module[base]) return class_module[base].split(' ')[0];
+    }
+    static getSelector(base, ...additional_classes) {
+        const gcn = this.getClassName(base, ...additional_classes);
+        if (gcn) return `.${gcn}`;
+    }
+
+    /**
+     * Returns all loaded modules.
+     * @return {Array}
+     */
+    static getAllModules() {
+        return this.require.c;
+    }
+
+    /**
+     * Returns an array of known modules.
+     * @return {Array}
+     */
+    static listKnownModules() {
+        return Object.keys(KnownModules);
+    }
+
+    static get KnownModules() { return KnownModules }
+
+}
+
+export { WebpackModules }

client/src/modules/security.js

@@ -0,0 +1,111 @@
+/**
+ * BetterDiscord Security Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import nodecrypto from 'node-crypto';
+import aes256 from 'aes256';
+
+export default class Security {
+
+    static encrypt(key, content, prefix = '') {
+        if (key instanceof Array || content instanceof Array) return this.deepEncrypt(key, content, prefix);
+        return `${prefix}${aes256.encrypt(key, content)}`;
+    }
+
+    static decrypt(key, content, prefix = '') {
+        if (key instanceof Array || content instanceof Array) {
+            return this.deepDecrypt(key, content, prefix);
+        }
+        return aes256.decrypt(key, content.replace(prefix, ''));
+    }
+
+    static deepEncrypt(keys, content, prefix = '') {
+        if (content && content instanceof Array) return this.deepEncryptContent(keys, content, prefix);
+        let encrypt = null;
+        for (const key of keys) {
+            if (encrypt === null) encrypt = this.encrypt(key, content, prefix);
+            else encrypt = this.encrypt(key, encrypt, prefix);
+        }
+        return encrypt;
+    }
+
+    static deepEncryptContent(key, contents, prefix = '') {
+        let encrypt = null;
+        for (const content of contents) {
+            if (encrypt === null) encrypt = this.encrypt(key, content, prefix);
+            else encrypt = this.encrypt(encrypt, content, prefix);
+        }
+        return encrypt;
+    }
+
+    static deepDecrypt(keys, content, prefix = '') {
+        if (content && content instanceof Array) return this.deepDecryptContent(keys, content, prefix);
+        let decrypt = null;
+        for (const key of keys.reverse()) {
+            if (decrypt === null) decrypt = this.decrypt(key, content, prefix);
+            else decrypt = this.decrypt(key, decrypt, prefix);
+        }
+        return decrypt;
+    }
+
+    static deepDecryptContent(key, contents, prefix = '') {
+        let decrypt = null;
+        for (const content of contents) {
+            if (decrypt === null) decrypt = this.decrypt(key, content, prefix);
+            else decrypt = this.decrypt(decrypt, content, prefix);
+        }
+        return decrypt;
+    }
+
+    static randomBytes(length = 64, to = 'hex') {
+        return nodecrypto.randomBytes(length).toString(to);
+    }
+
+    static async createHmac(key, data, algorithm = 'sha256') {
+        const hmac = nodecrypto.createHmac(algorithm, key);
+        return new Promise((resolve, reject) => {
+            hmac.on('readable', () => {
+                const data = hmac.read();
+                if (data) return resolve(data.toString('hex'));
+                reject(null);
+            });
+            hmac.write(data);
+            hmac.end();
+        });
+    }
+
+    static createECDH(curve = 'secp384r1') {
+        return nodecrypto.createECDH(curve);
+    }
+
+    static hash(algorithm, data, encoding) {
+        const hash = nodecrypto.createHash(algorithm);
+        hash.update(data);
+        return hash.digest(encoding);
+    }
+
+    static sha256(text) {
+        const hash = nodecrypto.createHash('sha256');
+        hash.update(text);
+        return hash.digest('base64');
+    }
+
+    static generateECDHKeys(ecdh) {
+        return ecdh.generateKeys('base64');
+    }
+
+    static getECDHPublicKey(ecdh) {
+        return ecdh.getPublicKey('base64');
+    }
+
+    static computeECDHSecret(ecdh, otherPublicKey) {
+        return ecdh.computeSecret(otherPublicKey, 'base64', 'base64');
+    }
+
+}

client/src/modules/settings.js

@@ -8,10 +8,158 @@
  * LICENSE file in the root directory of this source tree.
 */
 
+import { Toasts } from 'ui';
+import { SettingsSet } from 'structs';
+import { FileUtils, ClientLogger as Logger } from 'common';
+import path from 'path';
+import process from 'process';
+import Globals from './globals';
+import CssEditor from './csseditor';
+import Events from './events';
 import defaultSettings from '../data/user.settings.default';
 
-export default class {
-    static get getSettings() {
-        return defaultSettings;
+export default new class Settings {
+
+    constructor() {
+        this.settings = defaultSettings.map(_set => {
+            const set = new SettingsSet(_set);
+
+            set.on('setting-updated', event => {
+                const { category, setting, value, old_value } = event;
+                Logger.log('Settings', [`${set.id}/${category.id}/${setting.id} was changed from`, old_value, 'to', value]);
+                Events.emit('setting-updated', event);
+                Events.emit(`setting-updated-${set.id}_${category.id}_${setting.id}`, event);
+                Toasts.success(`${set.id}/${category.id}/${setting.id} was changed from ${old_value} to ${value}`); // Just for debugging purposes remove in prod
+            });
+
+            set.on('settings-updated', async event => {
+                if (!event.data || !event.data.dont_save) await this.saveSettings();
+                Events.emit('settings-updated', event);
+            });
+
+            return set;
+        });
+
+        // Set a hint for each platform for the use-keytar setting
+        const useKeytarSetting = this.getSetting('security', 'default', 'use-keytar');
+        if (process.platform === 'win32') useKeytarSetting.hint = 'Store the master password in Credential Manager';
+        if (process.platform === 'darwin') useKeytarSetting.hint = 'Store the master password in the default keychain';
+        if (process.platform === 'linux') useKeytarSetting.hint = 'Store the master password in libsecret';
     }
+
+    /**
+     * Loads BetterDiscord's settings.
+     */
+    async loadSettings() {
+        Logger.log('Settings', ['Loading settings']);
+
+        try {
+            await FileUtils.ensureDirectory(this.dataPath);
+
+            const settingsPath = path.resolve(this.dataPath, 'user.settings.json');
+            const user_config = await FileUtils.readJsonFromFile(settingsPath);
+            const { settings, scss, css, css_editor_files, scss_error, css_editor_bounds, favourite_emotes } = user_config;
+
+            for (const set of this.settings) {
+                const newSet = settings.find(s => s.id === set.id);
+                if (!newSet) continue;
+                await set.merge(newSet, {dont_save: true});
+                set.setSaved();
+            }
+
+            CssEditor.setState(scss, css, css_editor_files, scss_error);
+            CssEditor.editor_bounds = css_editor_bounds || {};
+        } catch (err) {
+            // There was an error loading settings
+            // This probably means that the user doesn't have any settings yet
+            Logger.warn('Settings', ['Failed to load internal settings', err]);
+        }
+    }
+
+    /**
+     * Saves BetterDiscord's settings including CSS editor data.
+     */
+    async saveSettings() {
+        Logger.log('Settings', ['Saving settings']);
+
+        try {
+            await FileUtils.ensureDirectory(this.dataPath);
+
+            const settingsPath = path.resolve(this.dataPath, 'user.settings.json');
+            await FileUtils.writeJsonToFile(settingsPath, {
+                settings: this.settings.map(set => set.strip()),
+                scss: CssEditor.scss,
+                css: CssEditor.css,
+                css_editor_files: CssEditor.files,
+                scss_error: CssEditor.error,
+                css_editor_bounds: CssEditor.editor_bounds
+            });
+
+            for (const set of this.settings) {
+                set.setSaved();
+            }
+        } catch (err) {
+            // There was an error saving settings
+            Logger.err('Settings', ['Failed to save internal settings', err]);
+            throw err;
+        }
+    }
+
+    /**
+     * Finds one of BetterDiscord's settings sets.
+     * @param {String} set_id The ID of the set to find
+     * @return {SettingsSet}
+     */
+    getSet(set_id) {
+        return this.settings.find(s => s.id === set_id);
+    }
+
+    get core() { return this.getSet('core') }
+    get ui() { return this.getSet('ui') }
+    get emotes() { return this.getSet('emotes') }
+    get css() { return this.getSet('css') }
+    get security() { return this.getSet('security') }
+
+    /**
+     * Finds a category in one of BetterDiscord's settings sets.
+     * @param {String} set_id The ID of the set to look in
+     * @param {String} category_id The ID of the category to find
+     * @return {SettingsCategory}
+     */
+    getCategory(set_id, category_id) {
+        const set = this.getSet(set_id);
+        return set ? set.getCategory(category_id) : undefined;
+    }
+
+    /**
+     * Finds a setting in one of BetterDiscord's settings sets.
+     * @param {String} set_id The ID of the set to look in
+     * @param {String} category_id The ID of the category to look in
+     * @param {String} setting_id The ID of the setting to find
+     * @return {Setting}
+     */
+    getSetting(set_id, category_id, setting_id) {
+        const set = this.getSet(set_id);
+        return set ? set.getSetting(category_id, setting_id) : undefined;
+    }
+
+    /**
+     * Returns a setting's value in one of BetterDiscord's settings sets.
+     * @param {String} set_id The ID of the set to look in
+     * @param {String} category_id The ID of the category to look in
+     * @param {String} setting_id The ID of the setting to find
+     * @return {Any}
+     */
+    get(set_id, category_id, setting_id) {
+        const set = this.getSet(set_id);
+        return set ? set.get(category_id, setting_id) : undefined;
+    }
+
+    /**
+     * The path to store user data in.
+     */
+    get dataPath() {
+        return Globals.getPath('data');
+    }
+
 }

client/src/modules/socketproxy.js

@@ -8,6 +8,7 @@
  * LICENSE file in the root directory of this source tree.
 */
 
+import { ClientLogger as Logger } from 'common';
 import EventListener from './eventlistener';
 
 export default class SocketProxy extends EventListener {
@@ -19,7 +20,7 @@ export default class SocketProxy extends EventListener {
 
     get eventBindings() {
         return [
-            { id: 'socket-created', 'callback': this.socketCreated }
+            { id: 'socket-created', callback: this.socketCreated }
         ];
     }
 
@@ -29,11 +30,11 @@ export default class SocketProxy extends EventListener {
 
     socketCreated(socket) {
         this.activeSocket = socket;
-       // socket.addEventListener('message', this.onMessage);
+        // socket.addEventListener('message', this.onMessage);
     }
 
     onMessage(e) {
-        console.info(e);
+        Logger.info('SocketProxy', e);
     }
 
 }

client/src/modules/theme.js

@@ -0,0 +1,176 @@
+/**
+ * BetterDiscord Theme Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import Content from './content';
+import Settings from './settings';
+import ThemeManager from './thememanager';
+import { DOM } from 'ui';
+import { FileUtils, ClientIPC, ClientLogger as Logger } from 'common';
+import filewatcher from 'filewatcher';
+
+export default class Theme extends Content {
+
+    constructor(internals) {
+        super(internals);
+
+        const watchfiles = Settings.getSetting('css', 'default', 'watch-files');
+        if (watchfiles.value) this.watchfiles = this.files;
+        watchfiles.on('setting-updated', event => {
+            if (event.value) this.watchfiles = this.files;
+            else this.watchfiles = [];
+        });
+    }
+
+    get type() { return 'theme' }
+    get css() { return this.data.css }
+
+    /**
+     * Called when settings are updated.
+     * This can be overridden by other content types.
+     */
+    __settingsUpdated(event) {
+        return this.recompile();
+    }
+
+    /**
+     * This is called when the theme is enabled.
+     */
+    async onstart() {
+        if (!this.css) await this.recompile();
+        DOM.injectTheme(this.css, this.id);
+    }
+
+    /**
+     * This is called when the theme is disabled.
+     */
+    onstop() {
+        DOM.deleteTheme(this.id);
+    }
+
+    /**
+     * Compiles the theme and returns an object containing the CSS and an array of files that were included.
+     * @return {Promise}
+     */
+    async compile() {
+        Logger.log(this.name, 'Compiling CSS');
+
+        if (this.info.type === 'sass') {
+            const config = await ThemeManager.getConfigAsSCSS(this.settings);
+
+            const result = await ClientIPC.send('bd-compileSass', {
+                data: config,
+                path: this.paths.mainPath.replace(/\\/g, '/')
+            });
+
+            // Why are these getters?
+            Logger.log(this.name, ['Finished compiling theme', new class Info {
+                get SCSS_variables() { console.log(config); return ''; }
+                get Compiled_SCSS() { console.log(result.css.toString()); return ''; }
+                get Result() { console.log(result); return ''; }
+            }]);
+
+            return {
+                css: result.css.toString(),
+                files: result.stats.includedFiles
+            };
+        }
+
+        return { css: await FileUtils.readFile(this.paths.mainPath) }
+    }
+
+    /**
+     * Compiles the theme and updates and saves the CSS and the list of include files.
+     * @return {Promise}
+     */
+    async recompile() {
+        const data = await this.compile();
+        this.data.css = data.css;
+        this.files = data.files;
+
+        await this.saveConfiguration();
+
+        if (this.enabled) {
+            DOM.deleteTheme(this.id);
+            DOM.injectTheme(this.css, this.id);
+        }
+    }
+
+    /**
+     * An array of files that are imported in the theme's SCSS.
+     * @return {Array} Files being watched
+     */
+    get files() {
+        return this.data.files || (this.data.files = []);
+    }
+
+    /**
+     * Sets all files that are imported in the theme's SCSS.
+     * @param {Array} files Files to watch
+     */
+    set files(files) {
+        this.data.files = files;
+
+        if (Settings.get('css', 'default', 'watch-files'))
+            this.watchfiles = files;
+    }
+
+    /**
+     * A filewatcher instance.
+     */
+    get filewatcher() {
+        if (this._filewatcher) return this._filewatcher;
+        this._filewatcher = filewatcher();
+        this._filewatcher.on('change', (file, stat) => {
+            // Recompile SCSS
+            this.recompile();
+        });
+        return this._filewatcher;
+    }
+
+    /**
+     * An array of files that are being watched for changes.
+     * @return {Array} Files being watched
+     */
+    get watchfiles() {
+        return this._watchfiles || (this._watchfiles = []);
+    }
+
+    /**
+     * Sets all files to be watched.
+     * @param {Array} files Files to watch
+     */
+    set watchfiles(files) {
+        if (this.packed) {
+            // Don't watch files for packed themes
+            return;
+        }
+
+        if (!files) files = [];
+
+        for (const file of files) {
+            if (!this.watchfiles.includes(file)) {
+                this.filewatcher.add(file);
+                this.watchfiles.push(file);
+                Logger.log(this.name, `Watching file ${file} for changes`);
+            }
+        }
+
+        for (const index in this.watchfiles) {
+            let file = this.watchfiles[index];
+            while (file && !files.find(f => f === file)) {
+                this.filewatcher.remove(file);
+                this.watchfiles.splice(index, 1);
+                Logger.log(this.name, `No longer watching file ${file} for changes`);
+                file = this.watchfiles[index];
+            }
+        }
+    }
+
+}

client/src/modules/thememanager.js

@@ -9,106 +9,121 @@
 */
 
 import ContentManager from './contentmanager';
-import { DOM } from 'ui';
-import { FileUtils } from 'common';
+import Theme from './theme';
 
-class Theme {
-
-    constructor(themeInternals) {
-        this.__themeInternals = themeInternals;
-        this.hasSettings = this.themeConfig && this.themeConfig.length > 0;
-        this.saveSettings = this.saveSettings.bind(this);
-        this.enable = this.enable.bind(this);
-        this.disable = this.disable.bind(this);
-    }
-
-    get configs() { return this.__themeInternals.configs }
-    get info() { return this.__themeInternals.info }
-    get icon() { return this.info.icon }
-    get paths() { return this.__themeInternals.paths }
-    get main() { return this.__themeInternals.main }
-    get defaultConfig() { return this.configs.defaultConfig }
-    get userConfig() { return this.configs.userConfig }
-    get name() { return this.info.name }
-    get authors() { return this.info.authors }
-    get version() { return this.info.version }
-    get themePath() { return this.paths.contentPath }
-    get dirName() { return this.paths.dirName }
-    get enabled() { return this.userConfig.enabled }
-    get themeConfig() { return this.userConfig.config }
-    get css() { return this.__themeInternals.css }
-    get id() { return this.name.toLowerCase().replace(/\s+/g, '-') }
-
-    async saveSettings(newSettings) {
-        if (newSettings) {
-            for (let category of newSettings) {
-                const oldCategory = this.themeConfig.find(c => c.category === category.category);
-                for (let setting of category.settings) {
-                    const oldSetting = oldCategory.settings.find(s => s.id === setting.id);
-                    if (oldSetting.value === setting.value) continue;
-                    oldSetting.value = setting.value;
-                    if (this.settingChanged) this.settingChanged(category.category, setting.id, setting.value);
-                }
-            }
-        }
-
-        try {
-            await FileUtils.writeFile(`${this.themePath}/user.config.json`, JSON.stringify({ enabled: this.enabled, config: this.themeConfig }));
-        } catch (err) {
-            throw err;
-        }
-
-        if (this.settingsChanged) this.settingsChanged(this.themeConfig);
-
-        return this.pluginConfig;
-    }
-
-    enable() {
-        this.userConfig.enabled = true;
-        this.saveSettings();
-        DOM.injectTheme(this.css, this.id);
-    }
-
-    disable() {
-        this.userConfig.enabled = false;
-        this.saveSettings();
-        DOM.deleteTheme(this.id);
-    }
-
-}
-
-export default class extends ContentManager {
+export default class ThemeManager extends ContentManager {
 
     static get localThemes() {
         return this.localContent;
     }
 
+    static get contentType() {
+        return 'theme';
+    }
+
+    static get moduleName() {
+        return 'Theme Manager';
+    }
+
     static get pathId() {
         return 'themes';
     }
 
-    static get loadAllThemes() {
-        return this.loadAllContent;
-    }
+    static get loadAllThemes() { return this.loadAllContent }
+    static get refreshThemes() { return this.refreshContent }
 
     static get loadContent() { return this.loadTheme }
     static async loadTheme(paths, configs, info, main) {
         try {
-            const css = await FileUtils.readFile(paths.mainPath);
-            const instance = new Theme({ configs, info, main, paths: { contentPath: paths.contentPath, dirName: paths.dirName }, css });
-            if (instance.enabled) instance.enable();
+            const instance = new Theme({
+                configs, info, main, paths
+            });
+            if (instance.enabled) {
+                instance.userConfig.enabled = false;
+                instance.enable();
+            }
             return instance;
         } catch (err) {
             throw err;
         }
     }
 
+    static get deleteTheme() { return this.deleteContent }
+    static get unloadTheme() { return this.unloadContent }
+    static async reloadTheme(theme) {
+        theme = await this.reloadContent(theme);
+        theme.recompile();
+    }
+
     static enableTheme(theme) {
-        theme.enable();
+        return theme.enable();
     }
 
     static disableTheme(theme) {
-        theme.disable();
+        return theme.disable();
+    }
+
+    static get isTheme() { return this.isThisContent }
+    static isThisContent(theme) {
+        return theme instanceof Theme;
+    }
+
+    /**
+     * Returns a representation of a settings set's values in SCSS.
+     * @param {SettingsSet} settingsset The set to convert to SCSS
+     * @return {Promise}
+     */
+    static async getConfigAsSCSS(settingsset) {
+        const variables = [];
+
+        for (const category of settingsset.categories) {
+            for (const setting of category.settings) {
+                const setting_scss = await this.parseSetting(setting);
+                if (setting_scss) variables.push(`$${setting_scss[0]}: ${setting_scss[1]};`);
+            }
+        }
+
+        return variables.join('\n');
+    }
+
+    /**
+     * Returns a representation of a settings set's values as an SCSS map.
+     * @param {SettingsSet} settingsset The set to convert to an SCSS map
+     * @return {Promise}
+     */
+    static async getConfigAsSCSSMap(settingsset) {
+        const variables = [];
+
+        for (const category of settingsset.categories) {
+            for (const setting of category.settings) {
+                const setting_scss = await this.parseSetting(setting);
+                if (setting_scss) variables.push(`${setting_scss[0]}: (${setting_scss[1]})`);
+            }
+        }
+
+        return `(${variables.join(', ')})`;
+    }
+
+    /**
+     * Returns a setting's name and value as a string that can be included in SCSS.
+     * @param {Setting} setting The setting to convert to SCSS
+     * @return {Promise}
+     */
+    static async parseSetting(setting) {
+        const name = setting.id.replace(/[^a-zA-Z0-9-]/g, '-').replace(/--/g, '-');
+        const scss = await setting.toSCSS();
+
+        if (scss) return [name, scss];
+    }
+
+    /**
+     * Escapes a string so it can be included in SCSS.
+     * @param {String} value The string to escape
+     * @return {String}
+     */
+    static toSCSSString(value) {
+        if (typeof value !== 'string' && value.toString) value = value.toString();
+        return `'${typeof value === 'string' ? value.replace(/\\/g, '\\\\').replace(/'/g, '\\\'') : ''}'`;
     }
 
 }

client/src/modules/updater.js

@@ -0,0 +1,190 @@
+/**
+ * BetterDiscord Updater Module
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { Notifications } from 'ui';
+import { Reflection, Globals } from 'modules';
+
+import Events from './events';
+import Module from './imodule';
+
+export default new class extends Module {
+
+    get updates() { return this.state.updates }
+    get bdUpdates() { return this.state.updates.bd }
+    get error() { return null; }
+    get updatesAvailable() { return this.state.updatesAvailable; }
+
+    constructor() {
+        super({
+            updatesAvailable: false,
+            error: null,
+            updates: { bd: [] },
+            updating: false
+        });
+    }
+
+    bindings() {
+        this.restartNotif = this.restartNotif.bind(this);
+        this.reloadNotif = this.reloadNotif.bind(this);
+        this.startUpdate = this.startUpdate.bind(this);
+        this.setUpdateStatus = this.setUpdateStatus.bind(this);
+        this.testUi = this.testUi.bind(this);
+    }
+
+    restartNotif() {
+        Notifications.add('Updates Finished!', 'Restart required.', [
+            {
+                text: 'Restart Later',
+                onClick: () => { setTimeout(this.restartNotif, 5 * 60000); return true; }
+            },
+            {
+                text: 'Restart Now',
+                onClick: () => {
+                    try {
+                        const { remote } = Globals.require('electron');
+                        window.close();
+                        Reflection.module.byProps('showToken', 'hideToken').showToken();
+                        remote.app.relaunch();
+                        remote.app.exit(0);
+                    } catch (err) {
+                        console.err(err);
+                        return true;
+                    }
+                }
+            }
+        ]);
+    }
+
+    reloadNotif() {
+        Notifications.add('Updates Finished!', 'Reload required.', [
+            {
+                text: 'Reload Later',
+                onClick: () => { setTimeout(this.reloadNotif, 5 * 60000); return true; }
+            },
+            {
+                text: 'Reload Now',
+                onClick: () => {
+                    document.location.reload();
+                }
+            }
+        ]);
+    }
+
+    events(ipc) {
+        ipc.on('updater-checkForUpdates', () => {
+            if (this.state.updating) return; // We're already updating. Updater should be paused anyways at this point.
+            Events.emit('update-check-start');
+        });
+
+        ipc.on('updater-noUpdates', () => {
+            if (this.state.updatesAvailable) return; // If for some reason we get this even though we have updates already.
+            this.setState({
+                updatesAvailable: false,
+                updates: {}
+            });
+        });
+
+        ipc.on('updater-updatesAvailable', (_, updates) => {
+            console.log(updates);
+            if (this.state.updating) return; // If for some reason we get more updates when we're already updating
+            updates.bd = updates.bd.map(update => {
+                update.text = `${update.id.charAt(0).toUpperCase()}${update.id.slice(1)}`;
+                update.hint = `Current: ${update.currentVersion} | Latest: ${update.version}`;
+                update.status = {
+                    update: true,
+                    updating: false,
+                    updated: false,
+                    error: null
+                };
+
+                return update;
+            });
+            this.setState({
+                updates,
+                updatesAvailable: true
+            });
+        });
+
+        ipc.on('updater-updated', (_, info) => {
+            const { reloadRequired, restartRequired } = info;
+            if (restartRequired) {
+                this.restartNotif();
+                return;
+            }
+
+            if (reloadRequired) {
+                this.reloadNotif();
+                return;
+            }
+        });
+
+        ipc.on('updater-updateFinished', (_, update) => {
+            this.setUpdateStatus(update.id, 'updated', true);
+        });
+
+        ipc.on('updater-updateError', (_, update) => {
+            this.setUpdateStatus(update.id, 'error', update.error);
+        });
+    }
+
+    stateChanged(oldState, newState) {
+        if (!newState.updatesAvailable) return Events.emit('update-check-end');
+        if (!oldState.updatesAvailable && newState.updatesAvailable) {
+            Events.emit('updates-available');
+            Notifications.add('', 'Updates Available!', [
+                {
+                    text: 'Ignore',
+                    onClick: () => { return true; }
+                },
+                {
+                    text: 'Show Updates',
+                    onClick: () => {
+                        Events.emit('bd-open-menu', 'updater');
+                        return true;
+                    }
+                }
+            ]);
+        }
+    }
+
+    setUpdateStatus(updateId, statusChild, statusValue) {
+        for (const u of this.bdUpdates) {
+            if (u.id === updateId) {
+                u.status[statusChild] = statusValue;
+                return;
+            }
+        }
+    }
+
+    toggleUpdate(update) {
+        update.status.update = !update.status.update;
+    }
+
+    async startUpdate() {
+        console.log('start update');
+        const updates = { bd: [] };
+        for (const update of this.bdUpdates) {
+            if (update.status.update) {
+                update.status.updating = true;
+                updates.bd.push(update);
+            }
+        }
+        console.log(updates);
+        this.send('updater-startUpdate', updates);
+    }
+
+    testUi(updates) {
+        this.setState({
+            updates,
+            updatesAvailable: true
+        });
+    }
+
+}

client/src/modules/vendor.js

@@ -8,30 +8,46 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-import WebpackModules from './webpackmodules';
 import jQuery from 'jquery';
 import lodash from 'lodash';
+import Vue from 'vue';
+import { Axi } from 'common';
+
+import request from 'request-promise-native';
+
+import Combokeys from 'combokeys';
+import filetype from 'file-type';
+import filewatcher from 'filewatcher';
+import VTooltip from 'v-tooltip';
+
+export { jQuery as $, request };
 
 export default class {
 
-    static get jQuery() {
-        return jQuery;
-    }
+    /**
+     * jQuery
+     */
+    static get jQuery() { return jQuery }
+    static get $() { return this.jQuery }
 
-    static get $() {
-        return this.jQuery;
-    }
+    /**
+     * Lodash
+     */
+    static get lodash() { return lodash }
+    static get _() { return this.lodash }
 
-    static get lodash() {
-        return lodash;
-    }
+    /**
+     * Vue
+     */
+    static get Vue() { return Vue }
 
-    static get _() {
-        return this.lodash;
-    }
+    static get axios() { return Axi.axios }
 
-    static get moment() {
-        return WebpackModules.getModuleByName('Moment');
-    }
+    static get request() { return request }
+
+    static get Combokeys() { return Combokeys }
+    static get filetype() { return filetype }
+    static get filewatcher() { return filewatcher }
+    static get VTooltip() { return VTooltip }
 
 }

client/src/modules/webpackmodules.js

@@ -1,260 +1,12 @@
-/**
- * BetterDiscord WebpackModules Module
- * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
- * All rights reserved.
- * https://betterdiscord.net
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
-*/
+/* Deprecation Notice */
+import { WebpackModules } from './reflection/wpm.depr.js';
+import { ClientLogger as Logger } from 'common';
 
-class Filters {
-    static byProperties(props, selector = m => m) {
-        return module => {
-            const component = selector(module);
-            if (!component) return false;
-            return props.every(property => component[property] !== undefined);
-        };
+const DeprecationWarning = new Proxy(WebpackModules, {
+    get(WebpackModules, property) {
+        Logger.warn('DEPR', 'WebpackModules is deprecated. Use Reflection.Modules instead.');
+        return WebpackModules[property] || WebpackModules.getModuleByName(property);
     }
+});
 
-    static byPrototypeFields(fields, selector = m => m) {
-        return module => {
-            const component = selector(module);
-            if (!component) return false;
-            if (!component.prototype) return false;
-            return fields.every(field => component.prototype[field] !== undefined);
-        };
-    }
-
-    static byCode(search, selector = m => m) {
-        return module => {
-            const method = selector(module);
-            if (!method) return false;
-            return method.toString().search(search) !== -1;
-        };
-    }
-
-    static byDisplayName(name) {
-        return module => {
-            return module && module.displayName === name;
-        };
-    }
-
-    static combine(...filters) {
-        return module => {
-            return filters.every(filter => filter(module));
-        };
-    }
-}
-
-const KnownModules = {
-    React: Filters.byProperties(['createElement', 'cloneElement']),
-    ReactDOM: Filters.byProperties(['render', 'findDOMNode']),
-
-    /* Guild Info, Stores, and Utilities */
-    GuildStore: Filters.byProperties(['getGuild']),
-    SortedGuildStore: Filters.byProperties(['getSortedGuilds']),
-    SelectedGuildStore: Filters.byProperties(['getLastSelectedGuildId']),
-    GuildSync: Filters.byProperties(["getSyncedGuilds"]),
-    GuildInfo: Filters.byProperties(["getAcronym"]),
-    GuildChannelsStore: Filters.byProperties(['getChannels', 'getDefaultChannel']),
-    GuildMemberStore: Filters.byProperties(['getMember']),
-    MemberCountStore: Filters.byProperties(["getMemberCounts"]),
-    GuildEmojiStore: Filters.byProperties(['getEmojis']),
-    GuildActions: Filters.byProperties(['markGuildAsRead']),
-    GuildPermissions: Filters.byProperties(['getGuildPermissions']),
-
-    /* Channel Store & Actions */
-    ChannelStore: Filters.byProperties(['getChannels', 'getDMFromUserId']),
-    SelectedChannelStore: Filters.byProperties(['getLastSelectedChannelId']),
-    ChannelActions: Filters.byProperties(["selectChannel"]),
-
-    /* Current User Info, State and Settings */
-    UserInfoStore: Filters.byProperties(["getToken"]),
-    UserSettingsStore: Filters.byProperties(["guildPositions"]),
-    AccountManager: Filters.byProperties(['register', 'login']),
-    UserSettingsUpdater: Filters.byProperties(['updateRemoteSettings']),
-    OnlineWatcher: Filters.byProperties(['isOnline']),
-    CurrentUserIdle: Filters.byProperties(['getIdleTime']),
-    RelationshipStore: Filters.byProperties(['isBlocked']),
-    MentionStore: Filters.byProperties(["getMentions"]),
-
-    /* User Stores and Utils */
-    UserStore: Filters.byProperties(['getCurrentUser']),
-    UserStatusStore: Filters.byProperties(['getStatuses']),
-    UserTypingStore: Filters.byProperties(['isTyping']),
-    UserActivityStore: Filters.byProperties(['getActivity']),
-    UserNameResolver: Filters.byProperties(['getName']),
-
-
-    /* Emoji Store and Utils */
-    EmojiInfo: Filters.byProperties(['isEmojiDisabled']),
-    EmojiUtils: Filters.byProperties(['diversitySurrogate']),
-    EmojiStore: Filters.byProperties(['getByCategory', 'EMOJI_NAME_RE']),
-
-    /* Invite Store and Utils */
-    InviteStore: Filters.byProperties(["getInvites"]),
-    InviteResolver: Filters.byProperties(['findInvite']),
-    InviteActions: Filters.byProperties(['acceptInvite']),
-
-
-    /* Discord Objects & Utils */
-    DiscordConstants: Filters.byProperties(["Permissions", "ActivityTypes", "StatusTypes"]),
-    Permissions: Filters.byProperties(['getHighestRole']),
-    ColorConverter: Filters.byProperties(['hex2int']),
-    ColorShader: Filters.byProperties(['darken']),
-    ClassResolver: Filters.byProperties(["getClass"]),
-    ButtonData: Filters.byProperties(["ButtonSizes"]),
-    IconNames: Filters.byProperties(["IconNames"]),
-
-    /* Discord Messages */
-    HistoryUtils: Filters.byProperties(['transitionTo', 'replaceWith', 'getHistory']),
-    MessageActions: Filters.byProperties(['jumpToMessage', '_sendMessage']),
-    MessageQueue: Filters.byProperties(['enqueue']),
-    MessageParser: Filters.byProperties(['createMessage', 'parse', 'unparse']),
-
-    /* In-Game Overlay */
-    OverlayUserPopoutSettings: Filters.byProperties(['openUserPopout']),
-    OverlayUserPopoutInfo: Filters.byProperties(['getOpenedUserPopout']),
-
-    /* Experiments */
-    ExperimentStore: Filters.byProperties(['getExperimentOverrides']),
-    ExperimentsManager: Filters.byProperties(['isDeveloper']),
-    CurrentExperiment: Filters.byProperties(['getExperimentId']),
-
-
-    /* Images, Avatars and Utils */
-    ImageResolver: Filters.byProperties(["getUserAvatarURL"]),
-    ImageUtils: Filters.byProperties(['getSizedImageSrc']),
-    AvatarDefaults: Filters.byProperties(["getUserAvatarURL", "DEFAULT_AVATARS"]),
-
-    /* Drag & Drop */
-    DNDActions: Filters.byProperties(["beginDrag"]),
-    DNDSources: Filters.byProperties(["addTarget"]),
-    DNDObjects: Filters.byProperties(["DragSource"]),
-
-    /* Electron & Other Internals with Utils*/
-    ElectronModule: Filters.byProperties(["_getMainWindow"]),
-    Dispatcher: Filters.byProperties(['dirtyDispatch']),
-    PathUtils: Filters.byProperties(["hasBasename"]),
-    NotificationModule: Filters.byProperties(["showNotification"]),
-    RouterModule: Filters.byProperties(["Router"]),
-    APIModule: Filters.byProperties(["getAPIBaseURL"]),
-    AnalyticEvents: Filters.byProperties(["AnalyticEventConfigs"]),
-    KeyGenerator: Filters.byCode(/"binary"/),
-    Buffers: Filters.byProperties(['Buffer', 'kMaxLength']),
-    DeviceStore: Filters.byProperties(['getDevices']),
-    SoftwareInfo: Filters.byProperties(["os"]),
-    CurrentContext: Filters.byProperties(["setTagsContext"]),
-
-    /* Media Stuff (Audio/Video) */
-    MediaDeviceInfo: Filters.byProperties(["Codecs", "SUPPORTED_BROWSERS"]),
-    MediaInfo: Filters.byProperties(["getOutputVolume"]),
-    MediaEngineInfo: Filters.byProperties(['MediaEngineFeatures']),
-    VoiceInfo: Filters.byProperties(["EchoCancellation"]),
-    VideoStream: Filters.byProperties(["getVideoStream"]),
-    SoundModule: Filters.byProperties(["playSound"]),
-
-    /* Window, DOM, HTML */
-    WindowInfo: Filters.byProperties(['isFocused', 'windowSize']),
-    TagInfo: Filters.byProperties(['VALID_TAG_NAMES']),
-    DOMInfo: Filters.byProperties(['canUseDOM']),
-    HTMLUtils: Filters.byProperties(['htmlFor', 'sanitizeUrl']),
-
-    /* Locale/Location and Time */
-    LocaleManager: Filters.byProperties(['setLocale']),
-    Moment: Filters.byProperties(['parseZone']),
-    LocationManager: Filters.byProperties(["createLocation"]),
-    Timestamps: Filters.byProperties(["fromTimestamp"]),
-
-    /* Strings and Utils */
-    Strings: Filters.byProperties(["TEXT", "TEXTAREA_PLACEHOLDER"]),
-    StringFormats: Filters.byProperties(['a', 'z']),
-    StringUtils: Filters.byProperties(["toASCII"]),
-
-    /* URLs and Utils */
-    URLParser: Filters.byProperties(['Url', 'parse']),
-    ExtraURLs: Filters.byProperties(['getArticleURL']),
-
-
-    /* DOM/React Components */
-    /* ==================== */
-    UserSettingsWindow: Filters.byProperties(['open', 'updateAccount']),
-    LayerManager: Filters.byProperties(['popLayer', 'pushLayer']),
-
-    /* Modals */
-    ModalStack: Filters.byProperties(['push', 'update', 'pop', 'popWithKey']),
-    UserProfileModals: Filters.byProperties(['fetchMutualFriends', 'setSection']),
-    ConfirmModal: Filters.byPrototypeFields(['handleCancel', 'handleSubmit', 'handleMinorConfirm']),
-
-    /* Popouts */
-    PopoutStack: Filters.byProperties(['open', 'close', 'closeAll']),
-    PopoutOpener: Filters.byProperties(['openPopout']),
-    EmojiPicker: Filters.byPrototypeFields(['onHoverEmoji', 'selectEmoji']),
-
-    /* Context Menus */
-    ContextMenuActions: Filters.byCode(/CONTEXT_MENU_CLOSE/, c => c.close),
-    ContextMenuItemsGroup: Filters.byCode(/itemGroup/),
-    ContextMenuItem: Filters.byCode(/\.label\b.*\.hint\b.*\.action\b/),
-
-    /* In-Message Links */
-    ExternalLink: Filters.byCode(/\.trusted\b/)
-};
-
-export default class {
-    /* Synchronous */
-    static getModuleByName(name, fallback) {
-        if (Cache.hasOwnProperty(name)) return Cache[name];
-        if (KnownModules.hasOwnProperty(name)) fallback = KnownModules[name];
-        if (!fallback) return null;
-        return Cache[name] = this.getModule(fallback, true);
-    }
-
-    static getModuleByDisplayName(name) {
-        return this.getModule(Filters.byDisplayName(name), true);
-    }
-
-    static getModuleByRegex(regex, first = true) {
-        return this.getModule(Filters.byCode(regex), first);
-    }
-
-    static getModuleByPrototypes(prototypes, first = true) {
-        return this.getModule(Filters.byPrototypeFields(prototypes), first);
-    }
-
-    static getModuleByProps(props, first = true) {
-        return this.getModule(Filters.byProperties(props), first);
-    }
-
-    static getModule(filter, first = true) {
-        const modules = this.getAllModules();
-        const rm = [];
-        for (let index in modules) {
-            if (!modules.hasOwnProperty(index)) continue;
-            const module = modules[index];
-            const { exports } = module;
-            let foundModule = null;
-
-            if (!exports) continue;
-            if (exports.__esModule && exports.default && filter(exports.default)) foundModule = exports.default;
-            if (filter(exports)) foundModule = exports;
-            if (!foundModule) continue;
-            if (first) return foundModule;
-            rm.push(foundModule);
-        }
-        return first || rm.length == 0 ? null : rm;
-    }
-
-    static getAllModules() {
-        const id = 'bd-webpackmodules';
-        const __webpack_require__ = window['webpackJsonp'](
-            [],
-            {
-                [id]: (module, exports, __webpack_require__) => exports.default = __webpack_require__
-            },
-            [id]).default;
-        delete __webpack_require__.m[id];
-        delete __webpack_require__.c[id];
-        return __webpack_require__.c;
-    }
-}
+export { DeprecationWarning as WebpackModules };

client/src/plugins/TimeStamps.js

@@ -1,3 +0,0 @@
-export default class {
-
-}

client/src/structs/discord/channel.js

@@ -0,0 +1,441 @@
+/*
+ * BetterDiscord Channel Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { DiscordApi, DiscordApiModules as Modules } from 'modules';
+import { List, InsufficientPermissions } from 'structs';
+import { Guild } from './guild';
+import { Message } from './message';
+import { User, GuildMember } from './user';
+
+const channels = new WeakMap();
+
+/**
+ * Class representing a Discord Channel
+ */
+export class Channel {
+
+    constructor(data) {
+        if (channels.has(data)) return channels.get(data);
+        channels.set(data, this);
+
+        this.discordObject = data;
+    }
+
+    static from(channel) {
+        switch (channel.type) {
+        default: return new Channel(channel);
+        case 0: return new GuildTextChannel(channel);
+        case 1: return new DirectMessageChannel(channel);
+        case 2: return new GuildVoiceChannel(channel);
+        case 3: return new GroupChannel(channel);
+        case 4: return new ChannelCategory(channel);
+        }
+    }
+
+    static fromId(id) {
+        const channel = Modules.ChannelStore.getChannel(id);
+        if (channel) return Channel.from(channel);
+    }
+
+    static get GuildChannel() { return GuildChannel }
+    static get GuildTextChannel() { return GuildTextChannel }
+    static get GuildVoiceChannel() { return GuildVoiceChannel }
+    static get ChannelCategory() { return ChannelCategory }
+    static get PrivateChannel() { return PrivateChannel }
+    static get DirectMessageChannel() { return DirectMessageChannel }
+    static get GroupChannel() { return GroupChannel }
+
+    get id() { return this.discordObject.id }
+    get applicationId() { return this.discordObject.application_id }
+    get type() { return this.discordObject.type }
+    get name() { return this.discordObject.name }
+
+    /**
+     * Send a message in this channel.
+     * @param {String} content The new message's content
+     * @param {Boolean} parse Whether to parse the message or send it as it is
+     * @return {Promise => Message}
+     */
+    async sendMessage(content, parse = false) {
+        if (this.assertPermissions) this.assertPermissions('SEND_MESSAGES', Modules.DiscordPermissions.VIEW_CHANNEL | Modules.DiscordPermissions.SEND_MESSAGES);
+
+        this.select();
+
+        if (parse) content = Modules.MessageParser.parse(this.discordObject, content);
+        else content = {content};
+
+        const response = await Modules.MessageActions._sendMessage(this.id, content);
+        return Message.from(Modules.MessageStore.getMessage(this.id, response.body.id));
+    }
+
+    /**
+     * Send a bot message in this channel that only the current user can see.
+     * @param {String} content The new message's content
+     * @return {Message}
+     */
+    sendBotMessage(content) {
+        this.select();
+        const message = Modules.MessageParser.createBotMessage(this.id, content);
+        Modules.MessageActions.receiveMessage(this.id, message);
+        return Message.from(Modules.MessageStore.getMessage(this.id, message.id));
+    }
+
+    /**
+     * A list of messages in this channel.
+     * @type {List<Message>}
+     */
+    get messages() {
+        const messages = Modules.MessageStore.getMessages(this.id).toArray();
+        return List.from(messages, m => Message.from(m));
+    }
+
+    /**
+     * Jumps to the latest message in this channel.
+     */
+    jumpToPresent() {
+        if (this.assertPermissions) this.assertPermissions('VIEW_CHANNEL', Modules.DiscordPermissions.VIEW_CHANNEL);
+        if (this.hasMoreAfter) Modules.MessageActions.jumpToPresent(this.id, Modules.DiscordConstants.MAX_MESSAGES_PER_CHANNEL);
+        else this.messages[this.messages.length - 1].jumpTo(false);
+    }
+
+    get hasMoreAfter() {
+        return Modules.MessageStore.getMessages(this.id).hasMoreAfter;
+    }
+
+    /**
+     * Sends an invite in this channel.
+     * @param {String} code The invite code
+     * @return {Promise => Messaage}
+     */
+    async sendInvite(code) {
+        if (this.assertPermissions) this.assertPermissions('SEND_MESSAGES', Modules.DiscordPermissions.VIEW_CHANNEL | Modules.DiscordPermissions.SEND_MESSAGES);
+        const response = Modules.MessageActions.sendInvite(this.id, code);
+        return Message.from(Modules.MessageStore.getMessage(this.id, response.body.id));
+    }
+
+    /**
+     * Opens this channel in the UI.
+     */
+    select() {
+        if (this.assertPermissions) this.assertPermissions('VIEW_CHANNEL', Modules.DiscordPermissions.VIEW_CHANNEL);
+        Modules.NavigationUtils.transitionToGuild(this.guildId ? this.guildId : Modules.DiscordConstants.ME, this.id);
+    }
+
+    /**
+     * Whether this channel is currently selected.
+     * @type {Boolean}
+     */
+    get isSelected() {
+        return DiscordApi.currentChannel === this;
+    }
+
+    /**
+     * Updates this channel.
+     * @return {Promise}
+     */
+    async updateChannel(body) {
+        if (this.assertPermissions) this.assertPermissions('MANAGE_CHANNELS', Modules.DiscordPermissions.MANAGE_CHANNELS);
+        const response = await Modules.APIModule.patch({
+            url: `${Modules.DiscordConstants.Endpoints.CHANNELS}/${this.id}`,
+            body
+        });
+
+        this.discordObject = Modules.ChannelStore.getChannel(this.id);
+        channels.set(this.discordObject, this);
+    }
+
+}
+
+export class PermissionOverwrite {
+    constructor(data, channel_id) {
+        this.discordObject = data;
+        this.channelId = channel_id;
+    }
+
+    static from(data, channel_id) {
+        switch (data.type) {
+        default: return new PermissionOverwrite(data, channel_id);
+        case 'role': return new RolePermissionOverwrite(data, channel_id);
+        case 'member': return new MemberPermissionOverwrite(data, channel_id);
+        }
+    }
+
+    static get RolePermissionOverwrite() { return RolePermissionOverwrite }
+    static get MemberPermissionOverwrite() { return MemberPermissionOverwrite }
+
+    get type() { return this.discordObject.type }
+    get allow() { return this.discordObject.allow }
+    get deny() { return this.discordObject.deny }
+
+    get channel() {
+        return Channel.fromId(this.channelId);
+    }
+
+    get guild() {
+        return this.channel ? this.channel.guild : null;
+    }
+}
+
+export class RolePermissionOverwrite extends PermissionOverwrite {
+    get roleId() { return this.discordObject.id }
+
+    get role() {
+        return this.guild ? this.guild.roles.find(r => r.id === this.roleId) : null;
+    }
+}
+
+export class MemberPermissionOverwrite extends PermissionOverwrite {
+    get memberId() { return this.discordObject.id }
+
+    get member() {
+        return GuildMember.fromId(this.memberId);
+    }
+}
+
+export class GuildChannel extends Channel {
+    static get PermissionOverwrite() { return PermissionOverwrite }
+
+    get guildId() { return this.discordObject.guild_id }
+    get parentId() { return this.discordObject.parent_id } // Channel category
+    get position() { return this.discordObject.position }
+    get nicks() { return this.discordObject.nicks }
+
+    checkPermissions(perms) {
+        return Modules.PermissionUtils.can(perms, DiscordApi.currentUser, this.discordObject);
+    }
+
+    assertPermissions(name, perms) {
+        if (!this.checkPermissions(perms)) throw new InsufficientPermissions(name);
+    }
+
+    get category() {
+        return Channel.fromId(this.parentId);
+    }
+
+    /**
+     * The current user's permissions on this channel.
+     */
+    get permissions() {
+        return Modules.GuildPermissions.getChannelPermissions(this.id);
+    }
+
+    get permissionOverwrites() {
+        return List.from(Object.entries(this.discordObject.permissionOverwrites), ([i, p]) => PermissionOverwrite.from(p, this.id));
+    }
+
+    get guild() {
+        return Guild.fromId(this.guildId);
+    }
+
+    /**
+     * Whether this channel is the guild's default channel.
+     */
+    get isDefaultChannel() {
+        return Modules.GuildChannelsStore.getDefaultChannel(this.guildId).id === this.id;
+    }
+
+    /**
+     * Opens this channel's settings window.
+     * @param {String} section The section to open (see DiscordConstants.ChannelSettingsSections)
+     */
+    openSettings(section = 'OVERVIEW') {
+        Modules.ChannelSettingsWindow.setSection(section);
+        Modules.ChannelSettingsWindow.open(this.id);
+    }
+
+    /**
+     * Updates this channel's name.
+     * @param {String} name The channel's new name
+     * @return {Promise}
+     */
+    updateName(name) {
+        return this.updateChannel({ name });
+    }
+
+    /**
+     * Changes the channel's position.
+     * @param {Number} position The channel's new position
+     * @return {Promise}
+     */
+    changeSortLocation(position = 0) {
+        if (position instanceof GuildChannel) position = position.position;
+        return this.updateChannel({ position });
+    }
+
+    /**
+     * Updates this channel's permission overwrites.
+     * @param {Array} permissionOverwrites An array of permission overwrites
+     * @return {Promise}
+     */
+    updatePermissionOverwrites(permission_overwrites) {
+        return this.updateChannel({ permission_overwrites });
+    }
+
+    /**
+     * Updates this channel's category.
+     * @param {ChannelCategory} category The new channel category
+     * @return {Promise}
+     */
+    updateCategory(category) {
+        return this.updateChannel({ parent_id: category.id || category });
+    }
+}
+
+// Type 0 - GUILD_TEXT
+export class GuildTextChannel extends GuildChannel {
+    get type() { return 'GUILD_TEXT' }
+    get topic() { return this.discordObject.topic }
+    get nsfw() { return this.discordObject.nsfw }
+
+    /**
+     * Updates this channel's topic.
+     * @param {String} topc The new channel topic
+     * @return {Promise}
+     */
+    updateTopic(topic) {
+        return this.updateChannel({ topic });
+    }
+
+    /**
+     * Updates this channel's not-safe-for-work flag.
+     * @param {Boolean} nsfw Whether the channel should be marked as NSFW
+     * @return {Promise}
+     */
+    setNsfw(nsfw = true) {
+        return this.updateChannel({ nsfw });
+    }
+
+    setNotNsfw() {
+        return this.setNsfw(false);
+    }
+}
+
+// Type 2 - GUILD_VOICE
+export class GuildVoiceChannel extends GuildChannel {
+    get type() { return 'GUILD_VOICE' }
+    get userLimit() { return this.discordObject.userLimit }
+    get bitrate() { return this.discordObject.bitrate }
+
+    sendMessage() { throw new Error('Cannot send messages in a voice channel.'); }
+    get messages() { return new List(); }
+    jumpToPresent() { throw new Error('Cannot select a voice channel.'); }
+    get hasMoreAfter() { return false; }
+    sendInvite() { throw new Error('Cannot invite someone to a voice channel.'); }
+    select() { throw new Error('Cannot select a voice channel.'); }
+
+    /**
+     * Updates this channel's bitrate.
+     * @param {Number} bitrate The new bitrate
+     * @return {Promise}
+     */
+    updateBitrate(bitrate) {
+        return this.updateChannel({ bitrate });
+    }
+
+    /**
+     * Updates this channel's user limit.
+     * @param {Number} userLimit The new user limit
+     * @return {Promise}
+     */
+    updateUserLimit(user_limit) {
+        return this.updateChannel({ user_limit });
+    }
+}
+
+// Type 4 - GUILD_CATEGORY
+export class ChannelCategory extends GuildChannel {
+    get type() { return 'GUILD_CATEGORY' }
+    get parentId() { return undefined }
+    get category() { return undefined }
+
+    sendMessage() { throw new Error('Cannot send messages in a channel category.'); }
+    get messages() { return new List(); }
+    jumpToPresent() { throw new Error('Cannot select a channel category.'); }
+    get hasMoreAfter() { return false; }
+    sendInvite() { throw new Error('Cannot invite someone to a channel category.'); }
+    select() { throw new Error('Cannot select a channel category.'); }
+    updateCategory() { throw new Error('Cannot set a channel category on another channel category.'); }
+
+    /**
+     * A list of channels in this category.
+     */
+    get channels() {
+        return List.from(this.guild.channels.filter(c => c.parentId === this.id));
+    }
+
+    /**
+     * Opens the create channel modal for this guild.
+     * @param {Number} type The type of channel to create - either 0 (text), 2 (voice) or 4 (category)
+     * @param {GuildChannel} clone A channel to clone permissions of
+     */
+    openCreateChannelModal(type, category, clone) {
+        this.guild.openCreateChannelModal(type, this.id, this, clone);
+    }
+
+    /**
+     * Creates a channel in this category.
+     * @param {Number} type The type of channel to create - either 0 (text) or 2 (voice)
+     * @param {String} name A name for the new channel
+     * @param {Array} permission_overwrites An array of PermissionOverwrite-like objects - leave to use the permissions of the category
+     * @return {Promise => GuildChannel}
+     */
+    createChannel(type, name, permission_overwrites) {
+        return this.guild.createChannel(type, name, this, permission_overwrites);
+    }
+}
+
+export class PrivateChannel extends Channel {
+    get userLimit() { return this.discordObject.userLimit }
+    get bitrate() { return this.discordObject.bitrate }
+}
+
+// Type 1 - DM
+export class DirectMessageChannel extends PrivateChannel {
+    get type() { return 'DM' }
+    get recipientId() { return this.discordObject.recipients[0] }
+
+    /**
+     * The other user of this direct message channel.
+     */
+    get recipient() {
+        return User.fromId(this.recipientId);
+    }
+}
+
+// Type 3 - GROUP_DM
+export class GroupChannel extends PrivateChannel {
+    get ownerId() { return this.discordObject.ownerId }
+    get type() { return 'GROUP_DM' }
+    get name() { return this.discordObject.name }
+    get icon() { return this.discordObject.icon }
+
+    /**
+     * A list of the other members of this group direct message channel.
+     */
+    get members() {
+        return List.from(this.discordObject.recipients, id => User.fromId(id));
+    }
+
+    /**
+     * The owner of this group direct message channel. This is usually the person who created it.
+     */
+    get owner() {
+        return User.fromId(this.ownerId);
+    }
+
+    /**
+     * Updates this channel's name.
+     * @param {String} name The channel's new name
+     * @return {Promise}
+     */
+    updateName(name) {
+        return this.updateChannel({ name });
+    }
+}

client/src/structs/discord/guild.js

@@ -0,0 +1,492 @@
+/*
+ * BetterDiscord Guild Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { DiscordApi, DiscordApiModules as Modules } from 'modules';
+import { List, InsufficientPermissions } from 'structs';
+import { FileUtils } from 'common';
+import { Channel } from './channel';
+import { GuildMember } from './user';
+
+const roles = new WeakMap();
+
+/**
+ * Class representing a Discord Role
+ */
+export class Role {
+    constructor(data, guild_id) {
+        if (roles.has(data)) return roles.get(data);
+        roles.set(data, this);
+
+        this.discordObject = data;
+        this.guildId = guild_id;
+    }
+
+    get id() { return this.discordObject.id }
+    get name() { return this.discordObject.name }
+    get position() { return this.discordObject.position }
+    get originalPosition() { return this.discordObject.originalPosition }
+    get permissions() { return this.discordObject.permissions }
+    get managed() { return this.discordObject.managed }
+    get mentionable() { return this.discordObject.mentionable }
+    get hoist() { return this.discordObject.hoist }
+    get colour() { return this.discordObject.color }
+    get colourString() { return this.discordObject.colorString }
+
+    get guild() {
+        return Guild.fromId(this.guildId);
+    }
+
+    get members() {
+        return this.guild.members.filter(m => m.roles.includes(this));
+    }
+}
+
+const emojis = new WeakMap();
+
+/**
+ * Class representing a Discord Emoji
+ */
+export class Emoji {
+    constructor(data) {
+        if (emojis.has(data)) return emojis.get(data);
+        emojis.set(data, this);
+
+        this.discordObject = data;
+    }
+
+    get id() { return this.discordObject.id }
+    get guildId() { return this.discordObject.guild_id }
+    get name() { return this.discordObject.name }
+    get managed() { return this.discordObject.managed }
+    get animated() { return this.discordObject.animated }
+    get allNamesString() { return this.discordObject.allNamesString }
+    get requireColons() { return this.discordObject.require_colons }
+    get url() { return this.discordObject.url }
+    get roles() { return this.discordObject.roles }
+
+    get guild() {
+        return Guild.fromId(this.guildId);
+    }
+}
+
+const guilds = new WeakMap();
+
+/**
+ * Class representing a Discord Guild
+ */
+export class Guild {
+
+    constructor(data) {
+        if (guilds.has(data)) return guilds.get(data);
+        guilds.set(data, this);
+
+        this.discordObject = data;
+    }
+
+    static from(data) {
+        return new Guild(data);
+    }
+
+    static fromId(id) {
+        const guild = Modules.GuildStore.getGuild(id);
+        if (guild) return Guild.from(guild);
+    }
+
+    static get Role() { return Role }
+    static get Emoji() { return Emoji }
+
+    get id() { return this.discordObject.id }
+    get ownerId() { return this.discordObject.ownerId }
+    get applicationId() { return this.discordObject.application_id }
+    get systemChannelId() { return this.discordObject.systemChannelId }
+    get name() { return this.discordObject.name }
+    get acronym() { return this.discordObject.acronym }
+    get icon() { return this.discordObject.icon }
+    get joinedAt() { return this.discordObject.joinedAt }
+    get verificationLevel() { return this.discordObject.verificationLevel }
+    get mfaLevel() { return this.discordObject.mfaLevel }
+    get large() { return this.discordObject.large }
+    get lazy() { return this.discordObject.lazy }
+    get voiceRegion() { return this.discordObject.region }
+    get afkChannelId() { return this.discordObject.afkChannelId }
+    get afkTimeout() { return this.discordObject.afkTimeout }
+    get explicitContentFilter() { return this.discordObject.explicitContentFilter }
+    get defaultMessageNotifications() { return this.discordObject.defaultMessageNotifications }
+    get splash() { return this.discordObject.splash }
+    get features() { return this.discordObject.features }
+
+    get owner() {
+        return this.members.find(m => m.userId === this.ownerId);
+    }
+
+    get roles() {
+        return List.from(Object.entries(this.discordObject.roles), ([i, r]) => new Role(r, this.id))
+            .sort((r1, r2) => r1.position === r2.position ? 0 : r1.position > r2.position ? 1 : -1);
+    }
+
+    get channels() {
+        const channels = Modules.GuildChannelsStore.getChannels(this.id);
+        const returnChannels = new List();
+        for (const category in channels) {
+            if (channels.hasOwnProperty(category)) {
+                if (!Array.isArray(channels[category])) continue;
+                const channelList = channels[category];
+                for (const channel of channelList) {
+                    // For some reason Discord adds a new category with the ID "null" and name "Uncategorized"
+                    if (channel.channel.id === 'null') continue;
+                    returnChannels.push(Channel.from(channel.channel));
+                }
+            }
+        }
+        return returnChannels;
+    }
+
+    /**
+     * Channels that don't have a parent. (Channel categories and any text/voice channel not in one.)
+     */
+    get mainChannels() {
+        return this.channels.filter(c => !c.parentId);
+    }
+
+    /**
+     * The guild's default channel. (Usually the first in the list.)
+     */
+    get defaultChannel() {
+        return Channel.from(Modules.GuildChannelsStore.getDefaultChannel(this.id));
+    }
+
+    /**
+     * The guild's AFK channel.
+     */
+    get afkChannel() {
+        return this.afkChannelId ? Channel.fromId(this.afkChannelId) : null;
+    }
+
+    /**
+     * The channel system messages are sent to.
+     */
+    get systemChannel() {
+        return this.systemChannelId ? Channel.fromId(this.systemChannelId) : null;
+    }
+
+    /**
+     * A list of GuildMember objects.
+     */
+    get members() {
+        const members = Modules.GuildMemberStore.getMembers(this.id);
+        return List.from(members, m => new GuildMember(m, this.id));
+    }
+
+    /**
+     * The current user as a GuildMember of this guild.
+     */
+    get currentUser() {
+        return this.members.find(m => m.user === DiscordApi.currentUser);
+    }
+
+    /**
+     * The total number of members in the guild.
+     */
+    get memberCount() {
+        return Modules.MemberCountStore.getMemberCount(this.id);
+    }
+
+    /**
+     * An array of the guild's custom emojis.
+     */
+    get emojis() {
+        return List.from(Modules.EmojiUtils.getGuildEmoji(this.id), e => new Emoji(e, this.id));
+    }
+
+    checkPermissions(perms) {
+        return Modules.PermissionUtils.can(perms, DiscordApi.currentUser, this.discordObject);
+    }
+
+    assertPermissions(name, perms) {
+        if (!this.checkPermissions(perms)) throw new InsufficientPermissions(name);
+    }
+
+    /**
+     * The current user's permissions on this guild.
+     */
+    get permissions() {
+        return Modules.GuildPermissions.getGuildPermissions(this.id);
+    }
+
+    /**
+     * Returns the GuildMember object for a user.
+     * @param {User|GuildMember|Number} user A User or GuildMember object or a user ID
+     * @return {GuildMember}
+     */
+    getMember(user) {
+        const member = Modules.GuildMemberStore.getMember(this.id, user.userId || user.id || user);
+        if (member) return new GuildMember(member, this.id);
+    }
+
+    /**
+     * Checks if a user is a member of this guild.
+     * @param {User|GuildMember|Number} user A User or GuildMember object or a user ID
+     * @return {Boolean}
+     */
+    isMember(user) {
+        return Modules.GuildMemberStore.isMember(this.id, user.userId || user.id || user);
+    }
+
+    /**
+     * Whether the user has not restricted direct messages from members of this guild.
+     */
+    get allowPrivateMessages() {
+        return !DiscordApi.UserSettings.restrictedGuildIds.includes(this.id);
+    }
+
+    /**
+     * Marks all messages in the guild as read.
+     */
+    markAsRead() {
+        Modules.GuildActions.markGuildAsRead(this.id);
+    }
+
+    /**
+     * Selects the guild in the UI.
+     */
+    select() {
+        Modules.GuildActions.selectGuild(this.id);
+    }
+
+    /**
+     * Whether this guild is currently selected.
+     */
+    get isSelected() {
+        return DiscordApi.currentGuild === this;
+    }
+
+    /**
+     * Opens this guild's settings window.
+     * @param {String} section The section to open (see DiscordConstants.GuildSettingsSections)
+     */
+    openSettings(section = 'OVERVIEW') {
+        Modules.GuildSettingsWindow.setSection(section);
+        Modules.GuildSettingsWindow.open(this.id);
+    }
+
+    /**
+     * Kicks members who don't have any roles and haven't been seen in the number of days passed.
+     * @param {Number} days
+     */
+    pruneMembers(days) {
+        this.assertPermissions('KICK_MEMBERS', Modules.DiscordPermissions.KICK_MEMBERS);
+        Modules.PruneMembersModal.prune(this.id, days);
+    }
+
+    openPruneMumbersModal() {
+        this.assertPermissions('KICK_MEMBERS', Modules.DiscordPermissions.KICK_MEMBERS);
+        Modules.PruneMembersModal.open(this.id);
+    }
+
+    /**
+     * Opens the create channel modal for this guild.
+     * @param {Number} type The type of channel to create - either 0 (text), 2 (voice) or 4 (category)
+     * @param {ChannelCategory} category The category to create the channel in
+     * @param {GuildChannel} clone A channel to clone permissions, topic, bitrate and user limit of
+     */
+    openCreateChannelModal(type, category, clone) {
+        this.assertPermissions('MANAGE_CHANNELS', Modules.DiscordPermissions.MANAGE_CHANNELS);
+        Modules.CreateChannelModal.open(type, this.id, category ? category.id : undefined, clone ? clone.id : undefined);
+    }
+
+    /**
+     * Creates a channel in this guild.
+     * @param {Number} type The type of channel to create - either 0 (text), 2 (voice) or 4 (category)
+     * @param {String} name A name for the new channel
+     * @param {ChannelCategory} category The category to create the channel in
+     * @param {Array} permission_overwrites An array of PermissionOverwrite-like objects - leave to use the permissions of the category
+     * @return {Promise => GuildChannel}
+     */
+    async createChannel(type, name, category, permission_overwrites) {
+        this.assertPermissions('MANAGE_CHANNELS', Modules.DiscordPermissions.MANAGE_CHANNELS);
+        const response = await Modules.APIModule.post({
+            url: Modules.DiscordConstants.Endpoints.GUILD_CHANNELS(this.id),
+            body: {
+                type, name,
+                parent_id: category ? category.id : undefined,
+                permission_overwrites: permission_overwrites ? permission_overwrites.map(p => ({
+                    type: p.type,
+                    id: (p.type === 'user' ? p.userId : p.roleId) || p.id,
+                    allow: p.allow,
+                    deny: p.deny
+                })) : undefined
+            }
+        });
+
+        return Channel.fromId(response.body.id);
+    }
+
+    openNotificationSettingsModal() {
+        Modules.NotificationSettingsModal.open(this.id);
+    }
+
+    openPrivacySettingsModal() {
+        Modules.PrivacySettingsModal.open(this.id);
+    }
+
+    nsfwAgree() {
+        Modules.GuildActions.nsfwAgree(this.id);
+    }
+
+    nsfwDisagree() {
+        Modules.GuildActions.nsfwDisagree(this.id);
+    }
+
+    /**
+     * Changes the guild's position in the list.
+     * @param {Number} index The new position
+     */
+    changeSortLocation(index) {
+        Modules.GuildActions.move(DiscordApi.guildPositions.indexOf(this.id), index);
+    }
+
+    /**
+     * Updates this guild.
+     * @return {Promise}
+     */
+    async updateGuild(body) {
+        this.assertPermissions('MANAGE_GUILD', Modules.DiscordPermissions.MANAGE_GUILD);
+        const response = await Modules.APIModule.patch({
+            url: Modules.DiscordConstants.Endpoints.GUILD(this.id),
+            body
+        });
+
+        this.discordObject = Modules.GuildStore.getGuild(this.id);
+        guilds.set(this.discordObject, this);
+    }
+
+    /**
+     * Updates this guild's name.
+     * @param {String} name The new name
+     * @return {Promise}
+     */
+    updateName(name) {
+        return this.updateGuild({ name });
+    }
+
+    /**
+     * Updates this guild's voice region.
+     * @param {String} region The ID of the new voice region (obtainable via the API - see https://discordapp.com/developers/docs/resources/voice#list-voice-regions)
+     * @return {Promise}
+     */
+    updateVoiceRegion(region) {
+        return this.updateGuild({ region });
+    }
+
+    /**
+     * Updates this guild's verification level.
+     * @param {Number} verificationLevel The new verification level (see https://discordapp.com/developers/docs/resources/guild#guild-object-verification-level)
+     * @return {Promise}
+     */
+    updateVerificationLevel(verification_level) {
+        return this.updateGuild({ verification_level });
+    }
+
+    /**
+     * Updates this guild's default message notification level.
+     * @param {Number} defaultMessageNotifications The new default notification level (0: all messages, 1: only mentions)
+     * @return {Promise}
+     */
+    updateDefaultMessageNotifications(default_message_notifications) {
+        return this.updateGuild({ default_message_notifications });
+    }
+
+    /**
+     * Updates this guild's explicit content filter level.
+     * @param {Number} explicitContentFilter The new explicit content filter level (0: disabled, 1: members without roles, 2: everyone)
+     * @return {Promise}
+     */
+    updateExplicitContentFilter(explicit_content_filter) {
+        return this.updateGuild({ explicit_content_filter });
+    }
+
+    /**
+     * Updates this guild's AFK channel.
+     * @param {GuildVoiceChannel} afkChannel The new AFK channel
+     * @return {Promise}
+     */
+    updateAfkChannel(afk_channel) {
+        return this.updateGuild({ afk_channel_id: afk_channel.id || afk_channel });
+    }
+
+    /**
+     * Updates this guild's AFK timeout.
+     * @param {Number} afkTimeout The new AFK timeout
+     * @return {Promise}
+     */
+    updateAfkTimeout(afk_timeout) {
+        return this.updateGuild({ afk_timeout });
+    }
+
+    /**
+     * Updates this guild's icon.
+     * @param {Buffer|String} icon A buffer/base 64 encoded 128x128 JPEG image
+     * @return {Promise}
+     */
+    updateIcon(icon) {
+        return this.updateGuild({ icon: typeof icon === 'string' ? icon : icon.toString('base64') });
+    }
+
+    /**
+     * Updates this guild's icon using a local file.
+     * TODO
+     * @param {String} icon_path The path to the new icon
+     * @return {Promise}
+     */
+    async updateIconFromFile(icon_path) {
+        const buffer = await FileUtils.readFileBuffer(icon_path);
+        return this.updateIcon(buffer);
+    }
+
+    /**
+     * Updates this guild's owner. (Should plugins really ever need to do this?)
+     * @param {User|GuildMember} owner The user/guild member to transfer ownership to
+     * @return {Promise}
+     */
+    updateOwner(owner) {
+        return this.updateGuild({ owner_id: owner.user ? owner.user.id : owner.id || owner });
+    }
+
+    /**
+     * Updates this guild's splash image.
+     * (I don't know what this is actually used for. The API documentation says it's VIP-only.)
+     * @param {Buffer|String} icon A buffer/base 64 encoded 128x128 JPEG image
+     * @return {Promise}
+     */
+    updateSplash(splash) {
+        return this.updateGuild({ splash: typeof splash === 'string' ? splash : splash.toString('base64') });
+    }
+
+    /**
+     * Updates this guild's splash image using a local file.
+     * TODO
+     * @param {String} splash_path The path to the new splash
+     * @return {Promise}
+     */
+    async updateSplashFromFile(splash_path) {
+        const buffer = await FileUtils.readFileBuffer(splash_path);
+        return this.updateSplash(buffer);
+    }
+
+    /**
+     * Updates this guild's system channel.
+     * @param {GuildTextChannel} systemChannel The new system channel
+     * @return {Promise}
+     */
+    updateSystemChannel(system_channel) {
+        return this.updateGuild({ system_channel_id: system_channel.id || system_channel });
+    }
+
+}

client/src/structs/discord/message.js

@@ -0,0 +1,319 @@
+/**
+ * BetterDiscord Message Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { DiscordApi, DiscordApiModules as Modules } from 'modules';
+import { List, InsufficientPermissions } from 'structs';
+import { Channel } from './channel';
+import { User } from './user';
+
+const reactions = new WeakMap();
+
+/**
+ * Class representing a Discord Reaction
+ */
+export class Reaction {
+    constructor(data, message_id, channel_id) {
+        if (reactions.has(data)) return reactions.get(data);
+        reactions.set(data, this);
+
+        this.discordObject = data;
+        this.messageId = message_id;
+        this.channelId = channel_id;
+    }
+
+    get emoji() {
+        const id = this.discordObject.emoji.id;
+        if (!id || !this.guild) return this.discordObject.emoji;
+        return this.guild.emojis.find(e => e.id === id);
+    }
+
+    get count() { return this.discordObject.count }
+    get me() { return this.discordObject.me }
+
+    get channel() {
+        return Channel.fromId(this.channel_id);
+    }
+
+    get message() {
+        return this.channel ? this.channel.messages.find(m => m.id === this.messageId) : null;
+    }
+
+    get guild() {
+        return this.channel ? this.channel.guild : null;
+    }
+}
+
+const embeds = new WeakMap();
+
+/**
+ * Class representing a Discord Embed
+ */
+export class Embed {
+    constructor(data, message_id, channel_id) {
+        if (embeds.has(data)) return embeds.get(data);
+        embeds.set(data, this);
+
+        this.discordObject = data;
+        this.messageId = message_id;
+        this.channelId = channel_id;
+    }
+
+    get title() { return this.discordObject.title }
+    get type() { return this.discordObject.type }
+    get description() { return this.discordObject.description }
+    get url() { return this.discordObject.url }
+    get timestamp() { return this.discordObject.timestamp }
+    get colour() { return this.discordObject.color }
+    get footer() { return this.discordObject.footer }
+    get image() { return this.discordObject.image }
+    get thumbnail() { return this.discordObject.thumbnail }
+    get video() { return this.discordObject.video }
+    get provider() { return this.discordObject.provider }
+    get author() { return this.discordObject.author }
+    get fields() { return this.discordObject.fields }
+
+    get channel() {
+        return Channel.fromId(this.channelId);
+    }
+
+    get message() {
+        return this.channel ? this.channel.messages.find(m => m.id === this.messageId) : null;
+    }
+
+    get guild() {
+        return this.channel ? this.channel.guild : null;
+    }
+}
+
+const messages = new WeakMap();
+
+/**
+ * Class representing a Discord Message
+ */
+export class Message {
+
+    constructor(data) {
+        if (messages.has(data)) return messages.get(data);
+        messages.set(data, this);
+
+        this.discordObject = data;
+    }
+
+    static from(data) {
+        switch (data.type) {
+        default: return new Message(data);
+        case 0: return new DefaultMessage(data);
+        case 1: return new RecipientAddMessage(data);
+        case 2: return new RecipientRemoveMessage(data);
+        case 3: return new CallMessage(data);
+        case 4: return new GroupChannelNameChangeMessage(data);
+        case 5: return new GroupChannelIconChangeMessage(data);
+        case 6: return new MessagePinnedMessage(data);
+        case 7: return new GuildMemberJoinMessage(data);
+        }
+    }
+
+    static get DefaultMessage() { return DefaultMessage }
+    static get RecipientAddMessage() { return RecipientAddMessage }
+    static get RecipientRemoveMessage() { return RecipientRemoveMessage }
+    static get CallMessage() { return CallMessage }
+    static get GroupChannelNameChangeMessage() { return GroupChannelNameChangeMessage }
+    static get GroupChannelIconChangeMessage() { return GroupChannelIconChangeMessage }
+    static get MessagePinnedMessage() { return MessagePinnedMessage }
+    static get GuildMemberJoinMessage() { return GuildMemberJoinMessage }
+
+    static get Reaction() { return Reaction }
+    static get Embed() { return Embed }
+
+    get id() { return this.discordObject.id }
+    get channelId() { return this.discordObject.channel_id }
+    get nonce() { return this.discordObject.nonce }
+    get type() { return this.discordObject.type }
+    get timestamp() { return this.discordObject.timestamp }
+    get state() { return this.discordObject.state }
+    get nick() { return this.discordObject.nick }
+    get colourString() { return this.discordObject.colorString }
+
+    get author() {
+        if (this.discordObject.author && !this.webhookId) return User.from(this.discordObject.author);
+        return null;
+    }
+
+    get channel() {
+        return Channel.fromId(this.channelId);
+    }
+
+    get guild() {
+        return this.channel ? this.channel.guild : null;
+    }
+
+    /**
+     * Deletes the message.
+     * @return {Promise}
+     */
+    delete() {
+        if (!this.isDeletable) throw new Error(`Message type ${this.type} is not deletable.`);
+        if (this.author === DiscordApi.currentUser) {}
+        else if (this.channel.assertPermissions) this.channel.assertPermissions('MANAGE_MESSAGES', Modules.DiscordPermissions.MANAGE_MESSAGES);
+        else if (!this.channel.owner === DiscordApi.currentUser) throw new InsufficientPermissions('MANAGE_MESSAGES');
+
+        return Modules.APIModule.delete(`${Modules.DiscordConstants.Endpoints.MESSAGES(this.channelId)}/${this.id}`);
+    }
+
+    get isDeletable() {
+        return this.type === 'DEFAULT' || this.type === 'CHANNEL_PINNED_MESSAGE' || this.type === 'GUILD_MEMBER_JOIN';
+    }
+
+    /**
+     * Jumps to the message.
+     */
+    jumpTo(flash = true) {
+        Modules.MessageActions.jumpToMessage(this.channelId, this.id, flash);
+    }
+
+}
+
+/**
+ * Class representing a default Discord Message
+ */
+export class DefaultMessage extends Message {
+    get webhookId() { return this.discordObject.webhookId }
+    get type() { return 'DEFAULT' }
+    get content() { return this.discordObject.content }
+    get contentParsed() { return this.discordObject.contentParsed }
+    get inviteCodes() { return this.discordObject.invites }
+    get attachments() { return this.discordObject.attachments }
+    get mentionIds() { return this.discordObject.mentions }
+    get mentionRoleIds() { return this.discordObject.mentionRoles }
+    get mentionEveryone() { return this.discordObject.mentionEveryone }
+    get editedTimestamp() { return this.discordObject.editedTimestamp }
+    get tts() { return this.discordObject.tts }
+    get mentioned() { return this.discordObject.mentioned }
+    get bot() { return this.discordObject.bot }
+    get blocked() { return this.discordObject.blocked }
+    get pinned() { return this.discordObject.pinned }
+    get activity() { return this.discordObject.activity }
+    get application() { return this.discordObject.application }
+
+    get webhook() {
+        return this.webhookId ? this.discordObject.author : null;
+    }
+
+    get mentions() {
+        return List.from(this.mentionIds, id => User.fromId(id));
+    }
+
+    get mention_roles() {
+        return List.from(this.mentionRoleIds, id => this.guild.roles.find(r => r.id === id));
+    }
+
+    get embeds() {
+        return List.from(this.discordObject.embeds, r => new Embed(r, this.id, this.channelId));
+    }
+
+    get reactions() {
+        return List.from(this.discordObject.reactions, r => new Reaction(r, this.id, this.channelId));
+    }
+
+    get edited() {
+        return !!this.editedTimestamp;
+    }
+
+    /**
+     * Programmatically update the message's content.
+     * @param {String} content The message's new content
+     * @param {Boolean} parse Whether to parse the message or update it as it is
+     * @return {Promise}
+     */
+    async edit(content, parse = false) {
+        if (this.author !== DiscordApi.currentUser) throw new Error('Cannot edit messages sent by other users.');
+        if (parse) content = Modules.MessageParser.parse(this.discordObject, content);
+        else content = {content};
+
+        const response = await Modules.APIModule.patch({
+            url: `${Modules.DiscordConstants.Endpoints.MESSAGES(this.channelId)}/${this.id}`,
+            body: content
+        });
+
+        this.discordObject = Modules.MessageStore.getMessage(this.id, response.body.id);
+        messages.set(this.discordObject, this);
+    }
+
+    /**
+     * Start the edit mode of the UI.
+     * @param {String} content A string to show in the message text area - if empty the message's current content will be used
+     */
+    startEdit(content) {
+        if (this.author !== DiscordApi.currentUser) throw new Error('Cannot edit messages sent by other users.');
+        Modules.MessageActions.startEditMessage(this.channelId, this.id, content || this.content);
+    }
+
+    /**
+     * Exit the edit mode of the UI.
+     */
+    endEdit() {
+        Modules.MessageActions.endEditMessage();
+    }
+}
+
+export class RecipientAddMessage extends Message {
+    get type() { return 'RECIPIENT_ADD' }
+    get addedUserId() { return this.discordObject.mentions[0] }
+
+    get addedUser() {
+        return User.fromId(this.addedUserId);
+    }
+}
+
+export class RecipientRemoveMessage extends Message {
+    get type() { return 'RECIPIENT_REMOVE' }
+    get removedUserId() { return this.discordObject.mentions[0] }
+
+    get removedUser() {
+        return User.fromId(this.removedUserId);
+    }
+
+    get userLeft() {
+        return this.author === this.removedUser;
+    }
+}
+
+export class CallMessage extends Message {
+    get type() { return 'CALL' }
+    get mentionIds() { return this.discordObject.mentions }
+    get call() { return this.discordObject.call }
+
+    get endedTimestamp() { return this.call.endedTimestamp }
+
+    get mentions() {
+        return List.from(this.mentionIds, id => User.fromId(id));
+    }
+
+    get participants() {
+        return List.from(this.call.participants, id => User.fromId(id));
+    }
+}
+
+export class GroupChannelNameChangeMessage extends Message {
+    get type() { return 'CHANNEL_NAME_CHANGE' }
+    get newName() { return this.discordObject.content }
+}
+
+export class GroupChannelIconChangeMessage extends Message {
+    get type() { return 'CHANNEL_ICON_CHANGE' }
+}
+
+export class MessagePinnedMessage extends Message {
+    get type() { return 'CHANNEL_PINNED_MESSAGE' }
+}
+
+export class GuildMemberJoinMessage extends Message {
+    get type() { return 'GUILD_MEMBER_JOIN' }
+}

client/src/structs/discord/user.js

@@ -0,0 +1,336 @@
+/*
+ * BetterDiscord User Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import { DiscordApi, DiscordApiModules as Modules } from 'modules';
+import { List, InsufficientPermissions } from 'structs';
+import { Utils } from 'common';
+import { Guild } from './guild';
+import { Channel } from './channel';
+
+const users = new WeakMap();
+
+/**
+ * Class representing a Discord user
+ */
+export class User {
+
+    constructor(data) {
+        if (users.has(data)) return users.get(data);
+        users.set(data, this);
+
+        this.discordObject = data;
+    }
+
+    static from(data) {
+        return new User(data);
+    }
+
+    static fromId(id) {
+        const user = Modules.UserStore.getUser(id);
+        if (user) return User.from(user);
+    }
+
+    static get GuildMember() { return GuildMember }
+
+    get id() { return this.discordObject.id }
+    get username() { return this.discordObject.username }
+    get usernameLowerCase() { return this.discordObject.usernameLowerCase }
+    get discriminator() { return this.discordObject.discriminator }
+    get avatar() { return this.discordObject.avatar }
+    get email() { return undefined }
+    get phone() { return undefined }
+    get flags() { return this.discordObject.flags }
+    get isBot() { return this.discordObject.bot }
+    get premium() { return this.discordObject.premium }
+    get verified() { return this.discordObject.verified }
+    get mfaEnabled() { return this.discordObject.mfaEnabled }
+    get mobile() { return this.discordObject.mobile }
+
+    get tag() { return this.discordObject.tag }
+    get avatarUrl() { return this.discordObject.avatarURL }
+    get createdAt() { return this.discordObject.createdAt }
+
+    get isClamied() { return this.discordObject.isClaimed() }
+    get isLocalBot() { return this.discordObject.isLocalBot() }
+    get isPhoneVerified() { return this.discordObject.isPhoneVerified() }
+
+    get guilds() {
+        return DiscordApi.guilds.filter(g => g.members.find(m => m.user === this));
+    }
+
+    get status() {
+        return Modules.UserStatusStore.getStatus(this.id);
+    }
+
+    get activity() {
+        // type can be either 0 (normal/rich presence game), 1 (streaming) or 2 (listening to Spotify)
+        // (3 appears as watching but is undocumented)
+        return Modules.UserStatusStore.getActivity(this.id);
+    }
+
+    get note() {
+        const note = Modules.UserNoteStore.getNote(this.id);
+        return note ? note : null;
+    }
+
+    /**
+     * Updates the note for this user.
+     * @param {String} note The new note
+     * @return {Promise}
+     */
+    updateNote(note) {
+        return Modules.APIModule.put({
+            url: `${Modules.DiscordConstants.Endpoints.NOTES}/${this.id}`,
+            body: { note }
+        });
+    }
+
+    get privateChannel() {
+        return DiscordApi.channels.find(c => c.type === 'DM' && c.recipientId === this.id);
+    }
+
+    async ensurePrivateChannel() {
+        if (DiscordApi.currentUser === this)
+            throw new Error('Cannot create a direct message channel to the current user.');
+        return Channel.fromId(await Modules.PrivateChannelActions.ensurePrivateChannel(DiscordApi.currentUser.id, this.id));
+    }
+
+    async sendMessage(content, parse = true) {
+        const channel = await this.ensurePrivateChannel();
+        return channel.sendMessage(content, parse);
+    }
+
+    get isFriend() {
+        return Modules.RelationshipStore.isFriend(this.id);
+    }
+
+    get isBlocked() {
+        return Modules.RelationshipStore.isBlocked(this.id);
+    }
+
+    addFriend() {
+        Modules.RelationshipManager.addRelationship(this.id, {location: 'Context Menu'});
+    }
+
+    removeFriend() {
+        Modules.RelationshipManager.removeRelationship(this.id, {location: 'Context Menu'});
+    }
+
+    block() {
+        Modules.RelationshipManager.addRelationship(this.id, {location: 'Context Menu'}, Modules.DiscordConstants.RelationshipTypes.BLOCKED);
+    }
+
+    unblock() {
+        Modules.RelationshipManager.removeRelationship(this.id, {location: 'Context Menu'});
+    }
+
+    /**
+     * Opens the profile modal for this user.
+     * @param {String} section The section to open (see DiscordConstants.UserProfileSections)
+     */
+    openUserProfileModal(section = 'USER_INFO') {
+        Modules.UserProfileModal.open(this.id);
+        Modules.UserProfileModal.setSection(section);
+    }
+
+}
+
+const guild_members = new WeakMap();
+
+/**
+ * Class representing a Discord Guild Member
+ */
+export class GuildMember {
+    constructor(data, guild_id) {
+        if (guild_members.has(data)) return guild_members.get(data);
+        guild_members.set(data, this);
+
+        this.discordObject = data;
+        this.guildId = guild_id;
+    }
+
+    get userId() { return this.discordObject.userId }
+    get nickname() { return this.discordObject.nick }
+    get colourString() { return this.discordObject.colorString }
+    get hoistRoleId() { return this.discordObject.hoistRoleId }
+    get roleIds() { return this.discordObject.roles }
+
+    get user() {
+        return User.fromId(this.userId);
+    }
+
+    get name() {
+        return this.nickname || this.user.username;
+    }
+
+    get guild() {
+        return Guild.fromId(this.guildId);
+    }
+
+    get roles() {
+        return List.from(this.roleIds, id => this.guild.roles.find(r => r.id === id))
+            .sort((r1, r2) => r1.position === r2.position ? 0 : r1.position > r2.position ? 1 : -1);
+    }
+
+    get hoistRole() {
+        return this.guild.roles.find(r => r.id === this.hoistRoleId);
+    }
+
+    checkPermissions(perms) {
+        return Modules.PermissionUtils.can(perms, DiscordApi.currentUser.discordObject, this.guild.discordObject);
+    }
+
+    assertPermissions(name, perms) {
+        if (!this.checkPermissions(perms)) throw new InsufficientPermissions(name);
+    }
+
+    /**
+     * Opens the modal to change this user's nickname.
+     */
+    openChangeNicknameModal() {
+        if (DiscordApi.currentUser === this.user)
+            this.assertPermissions('CHANGE_NICKNAME', Modules.DiscordPermissions.CHANGE_NICKNAME);
+        else this.assertPermissions('MANAGE_NICKNAMES', Modules.DiscordPermissions.MANAGE_NICKNAMES);
+
+        Modules.ChangeNicknameModal.open(this.guildId, this.userId);
+    }
+
+    /**
+     * Changes the user's nickname on this guild.
+     * @param {String} nickname The user's new nickname
+     * @return {Promise}
+     */
+    changeNickname(nick) {
+        if (DiscordApi.currentUser === this.user)
+            this.assertPermissions('CHANGE_NICKNAME', Modules.DiscordPermissions.CHANGE_NICKNAME);
+        else this.assertPermissions('MANAGE_NICKNAMES', Modules.DiscordPermissions.MANAGE_NICKNAMES);
+
+        return Modules.APIModule.patch({
+            url: `${Modules.DiscordConstants.Endpoints.GUILD_MEMBERS(this.guild_id)}/${DiscordApi.currentUser === this.user ? '@me/nick' : this.userId}`,
+            body: { nick }
+        });
+    }
+
+    /**
+     * Kicks this user from the guild.
+     * @param {String} reason A reason to attach to the audit log entry
+     * @return {Promise}
+     */
+    kick(reason = '') {
+        this.assertPermissions('KICK_MEMBERS', Modules.DiscordPermissions.KICK_MEMBERS);
+        return Modules.GuildActions.kickUser(this.guildId, this.userId, reason);
+    }
+
+    /**
+     * Bans this user from the guild.
+     * @param {Number} daysToDelete The number of days of the user's recent message history to delete
+     * @param {String} reason A reason to attach to the audit log entry
+     * @return {Promise}
+     */
+    ban(daysToDelete = 1, reason = '') {
+        this.assertPermissions('BAN_MEMBERS', Modules.DiscordPermissions.BAN_MEMBERS);
+        return Modules.GuildActions.banUser(this.guildId, this.userId, daysToDelete, reason);
+    }
+
+    /**
+     * Removes the ban for this user.
+     * @return {Promise}
+     */
+    unban() {
+        this.assertPermissions('BAN_MEMBERS', Modules.DiscordPermissions.BAN_MEMBERS);
+        return Modules.GuildActions.unbanUser(this.guildId, this.userId);
+    }
+
+    /**
+     * Moves this user to another voice channel.
+     * @param {GuildVoiceChannel} channel The channel to move this user to
+     */
+    move(channel) {
+        this.assertPermissions('MOVE_MEMBERS', Modules.DiscordPermissions.MOVE_MEMBERS);
+        Modules.GuildActions.setChannel(this.guildId, this.userId, channel.id);
+    }
+
+    /**
+     * Mutes this user for everyone in the guild.
+     */
+    mute(active = true) {
+        this.assertPermissions('MUTE_MEMBERS', Modules.DiscordPermissions.MUTE_MEMBERS);
+        Modules.GuildActions.setServerMute(this.guildId, this.userId, active);
+    }
+
+    /**
+     * Unmutes this user.
+     */
+    unmute() {
+        this.mute(false);
+    }
+
+    /**
+     * Deafens this user.
+     */
+    deafen(active = true) {
+        this.assertPermissions('DEAFEN_MEMBERS', Modules.DiscordPermissions.DEAFEN_MEMBERS);
+        Modules.GuildActions.setServerDeaf(this.guildId, this.userId, active);
+    }
+
+    /**
+     * Undeafens this user.
+     */
+    undeafen() {
+        this.deafen(false);
+    }
+
+    /**
+     * Gives this user a role.
+     * @param {Role} role The role to add
+     * @return {Promise}
+     */
+    addRole(...roles) {
+        const newRoles = this.roleIds.concat([]);
+        let changed = false;
+        for (const role of roles) {
+            if (newRoles.includes(role.id || role)) continue;
+            newRoles.push(role.id || role);
+            changed = true;
+        }
+        if (!changed) return;
+        return this.updateRoles(newRoles);
+    }
+
+    /**
+     * Removes a role from this user.
+     * @param {Role} role The role to remove
+     * @return {Promise}
+     */
+    removeRole(...roles) {
+        const newRoles = this.roleIds.concat([]);
+        let changed = false;
+        for (const role of roles) {
+            if (!newRoles.includes(role.id || role)) continue;
+            Utils.removeFromArray(newRoles, role.id || role);
+            changed = true;
+        }
+        if (!changed) return;
+        return this.updateRoles(newRoles);
+    }
+
+    /**
+     * Updates this user's roles.
+     * @param {Array} roles An array of Role objects or role IDs
+     * @return {Promise}
+     */
+    updateRoles(roles) {
+        roles = roles.map(r => r.id || r);
+        return Modules.APIModule.patch({
+            url: `${Modules.DiscordConstants.Endpoints.GUILD_MEMBERS(this.guildId)}/${this.userId}`,
+            body: { roles }
+        });
+    }
+}

client/src/structs/discordstructs.js

@@ -0,0 +1,4 @@
+export * from './discord/user';
+export * from './discord/guild';
+export * from './discord/channel';
+export * from './discord/message';

client/src/structs/events/error.js

@@ -8,31 +8,48 @@
  * LICENSE file in the root directory of this source tree.
 */
 
-export class Error {
+import Event from './event';
+
+export default class ErrorEvent extends Event {
 
     constructor(args) {
-        this.args = args;
+        super(args);
         this.showStack = false; // For error modal
     }
 
+    /**
+     * The module the error occured in.
+     */
     get module() {
         return this.args.module;
     }
 
+    /**
+     * A message describing the error.
+     */
     get message() {
         return this.args.message;
     }
 
+    /**
+     * The original error object.
+     */
     get err() {
         return this.args.err;
     }
 
+    /**
+     * A trace showing which functions were called when the error occured.
+     */
     get stackTrace() {
         return this.err.stack;
     }
 
-    get _type() {
-        return 'err';
+    /**
+     * The type of event.
+     */
+    get __eventType() {
+        return 'error';
     }
 
 }

client/src/structs/events/event.js

@@ -0,0 +1,46 @@
+/**
+ * BetterDiscord Base Event Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+export default class Event {
+
+    constructor(args) {
+        this.__eventInfo = {
+            args: arguments,
+            type: this.__eventType
+        };
+    }
+
+    /**
+     * An object containing information about the event.
+     */
+    get event() {
+        return this.__eventInfo;
+    }
+
+    /**
+     * Extra data associated with this event.
+     */
+    get data() {
+        return this.args.data;
+    }
+
+    /**
+     * The first argument that was passed to the constructor, which contains information about the event.
+     */
+    get args() {
+        return this.event.args[0];
+    }
+
+    /**
+     * The type of event.
+     */
+    get __eventType() { return undefined; }
+
+}

client/src/structs/events/index.js

@@ -0,0 +1,4 @@
+export { default as SettingUpdatedEvent } from './settingupdated';
+export { default as SettingsUpdatedEvent } from './settingsupdated';
+export { default as ErrorEvent } from './error';
+export { PermissionsError, InsufficientPermissions } from './permissionserror';

client/src/structs/events/permissionserror.js

@@ -0,0 +1,25 @@
+/**
+ * BetterDiscord Permissions Error Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import ErrorEvent from './error';
+
+export class PermissionsError extends ErrorEvent {
+    constructor(message) {
+        super(message);
+        this.name = 'PermissionsError';
+    }
+}
+
+export class InsufficientPermissions extends PermissionsError {
+    constructor(message) {
+        super(`Missing Permission — ${message}`);
+        this.name = 'InsufficientPermissions';
+    }
+}

client/src/structs/events/settingsupdated.js

@@ -0,0 +1,29 @@
+/**
+ * BetterDiscord Settings Updated Event Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import Event from './event';
+
+export default class SettingsUpdatedEvent extends Event {
+
+    /**
+     * An array of SettingUpdated events.
+     */
+    get updatedSettings() {
+        return this.args.updatedSettings;
+    }
+
+    /**
+     * The type of event.
+     */
+    get __eventType() {
+        return 'settings-updated';
+    }
+
+}

client/src/structs/events/settingupdated.js

@@ -0,0 +1,78 @@
+/**
+ * BetterDiscord Setting Updated Event Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+import Event from './event';
+
+export default class SettingUpdatedEvent extends Event {
+
+    /**
+     * The set containing the setting that was updated.
+     */
+    get set() {
+        return this.args.set;
+    }
+
+    /**
+     * The ID of the set containing the setting that was updated.
+     */
+    get set_id() {
+        return this.set.id;
+    }
+
+    /**
+     * The category containing the setting that was updated.
+     */
+    get category() {
+        return this.args.category;
+    }
+
+    /**
+     * The ID of the category containing the setting that was updated.
+     */
+    get category_id() {
+        return this.category.id;
+    }
+
+    /**
+     * The setting that was updated.
+     */
+    get setting() {
+        return this.args.setting;
+    }
+
+    /**
+     * The ID of the setting that was updated.
+     */
+    get setting_id() {
+        return this.setting.id;
+    }
+
+    /**
+     * The setting's new value.
+     */
+    get value() {
+        return this.args.value;
+    }
+
+    /**
+     * The setting's old value.
+     */
+    get old_value() {
+        return this.args.old_value;
+    }
+
+    /**
+     * The type of event.
+     */
+    get __eventType() {
+        return 'setting-updated';
+    }
+
+}

client/src/structs/list.js

@@ -0,0 +1,31 @@
+/*
+ * BetterDiscord List
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+*/
+
+/**
+ * Class representing a list.
+ * @extends Array
+ */
+
+export default class List extends Array {
+
+    get(...filters) {
+        return this.find(item => {
+            for (const filter of filters) {
+                for (const key in filter) {
+                    if (filter.hasOwnProperty(key)) {
+                        if (item[key] !== filter[key]) return false;
+                    }
+                }
+            }
+            return true;
+        });
+    }
+
+}

client/src/structs/settings/index.js

@@ -0,0 +1,5 @@
+export { default as SettingsSet } from './settingsset';
+export { default as SettingsCategory } from './settingscategory';
+export { default as Setting } from './setting';
+export { default as SettingsScheme } from './settingsscheme';
+export * from './types';

client/src/structs/settings/multiplechoiceoption.js

@@ -0,0 +1,40 @@
+/**
+ * BetterDiscord Multiple Choice Option Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export default class MultipleChoiceOption {
+
+    constructor(args) {
+        this.args = args.args || args;
+
+        Object.freeze(this);
+    }
+
+    /**
+     * This option's ID.
+     */
+    get id() {
+        return this.args.id || this.value;
+    }
+
+    /**
+     * A string describing this option.
+     */
+    get text() {
+        return this.args.text;
+    }
+
+    /**
+     * The value to return when this option is active.
+     */
+    get value() {
+        return this.args.value;
+    }
+
+}

client/src/structs/settings/setting.js

@@ -0,0 +1,53 @@
+/**
+ * BetterDiscord Setting Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import BoolSetting from './types/bool';
+import StringSetting from './types/text';
+import NumberSetting from './types/number';
+import DropdownSetting from './types/dropdown';
+import RadioSetting from './types/radio';
+import SliderSetting from './types/slider';
+import ColourSetting from './types/colour';
+import KeybindSetting from './types/keybind';
+import FileSetting from './types/file';
+import GuildSetting from './types/guild';
+import ArraySetting from './types/array';
+import CollectionSetting from './types/collection';
+import KvpSetting from './types/kvp';
+import SecureKvpSetting from './types/securekvp';
+import CustomSetting from './types/custom';
+
+export default class Setting {
+
+    constructor(args, ...merge) {
+        args = args.args || args;
+
+        if (args.type instanceof Array) args.subtype = args.type[0], args.type = 'collection';
+        if (args.type === 'color') args.type = 'colour';
+
+        if (args.type === 'bool') return new BoolSetting(args, ...merge);
+        else if (args.type === 'text') return new StringSetting(args, ...merge);
+        else if (args.type === 'number') return new NumberSetting(args, ...merge);
+        else if (args.type === 'dropdown') return new DropdownSetting(args, ...merge);
+        else if (args.type === 'radio') return new RadioSetting(args, ...merge);
+        else if (args.type === 'slider') return new SliderSetting(args, ...merge);
+        else if (args.type === 'colour') return new ColourSetting(args, ...merge);
+        else if (args.type === 'keybind') return new KeybindSetting(args, ...merge);
+        else if (args.type === 'file') return new FileSetting(args, ...merge);
+        else if (args.type === 'guild') return new GuildSetting(args, ...merge);
+        else if (args.type === 'array') return new ArraySetting(args, ...merge);
+        else if (args.type === 'collection') return new CollectionSetting(args, ...merge);
+        else if (args.type === 'kvp') return new KvpSetting(args, ...merge);
+        else if (args.type === 'securekvp') return new SecureKvpSetting(args, ...merge);
+        else if (args.type === 'custom') return new CustomSetting(args, ...merge);
+        throw {message: `Setting type ${args.type} unknown`};
+    }
+
+}

client/src/structs/settings/settingscategory.js

@@ -0,0 +1,306 @@
+/**
+ * BetterDiscord Settings Category Struct
+ * Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
+ * All rights reserved.
+ * https://betterdiscord.net
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { SettingUpdatedEvent, SettingsUpdatedEvent } from 'structs';
+import { ClientLogger as Logger, AsyncEventEmitter } from 'common';
+import Setting from './setting';
+import BaseSetting from './types/basesetting';
+import SettingsProxy from './settingsproxy';
+
+export default class SettingsCategory extends AsyncEventEmitter {
+
+    constructor(args, ...merge) {
+        super();
+
+        if (typeof args === 'string')
+            args = {id: args};
+        this.args = args.args || args || {};
+
+        this.args.id = this.args.id || this.args.category || 'default';
+        this.args.name = this.args.name || this.args.category_name || this.id;
+        this.type = this.args.type;
+
+        this.args.settings = this.settings.map(setting => new Setting(setting));
+
+        for (const newCategory of merge) {
+            this._merge(newCategory);
+        }
+
+        this.__settingUpdated = this.__settingUpdated.bind(this);
+        this.__settingsUpdated = this.__settingsUpdated.bind(this);
+
+        for (const setting of this.settings) {
+            setting.on('setting-updated', this.__settingUpdated);
+            setting.on('settings-updated', this.__settingsUpdated);
+        }
+    }
+
+    /**
+     * Category ID
+     */
+    get id() {
+        return this.args.id || this.args.category;
+    }
+
+    get category() {
+        return this.id;
+    }
+
+    /**
+     * Category name
+     */
+    get name() {
+        return this.args.name || this.args.category_name;
+    }
+
+    get category_name() {
+        return this.name;
+    }
+
+    set name(value) {
+        this.args.name = value;
+    }
+
+    /**
+     * Category type
+     * Currently either "drawer", "static", or undefined.
+     */
+    get type() {
+        return this.args.type;
+    }
+
+    set type(value) {
+        if (!value) this.args.type = undefined;
+        else if (value === 'drawer' || value === 'static')
+            this.args.type = value;
+        else throw {message: `Invalid category type ${value}`};
+    }
+
+    /**
+     * An array of settings in this category.
+     */
+    get settings() {
+        return this.args.settings || [];
+    }
+
+    /**
+     * Whether any setting in this category has been changed.
+     */
+    get changed() {
+        if (this.settings.find(setting => setting.changed)) return true;
+        return false;
+    }
+
+    /**
+     * Setting event listeners.
+     * This only exists for use by the constructor and settingscategory.addSetting.
+     */
+    __settingUpdated({ setting, value, old_value }) {
+        return this.emit('setting-updated', new SettingUpdatedEvent({
+            category: this, category_id: this.id,
+            setting, setting_id: setting.id,
+            value, old_value
+        }));
+    }
+
+    __settingsUpdated({ updatedSettings }) {
+        return this.emit('settings-updated', new SettingsUpdatedEvent({
+            updatedSettings: updatedSettings.map(updatedSetting => new SettingUpdatedEvent(Object.assign({
+                category: this, category_id: this.id
+            }, updatedSetting)))
+        }));
+    }
+
+    /**
+     * Dynamically adds a setting to this category.
+     * @param {Setting} category The setting to add to this category
+     * @param {Number} index The index to add the setting at (optional)
+     * @return {Promise}
+     */
+    async addSetting(setting, index) {
+        if (this.settings.find(s => s === setting)) return;
+
+        if (!(setting instanceof BaseSetting))
+            setting = new Setting(setting);
+
+        if (this.getSetting(setting.id))
+            throw {message: 'A setting with this ID already exists.'};
+
+        setting.on('setting-updated', this.__settingUpdated);
+        setting.on('settings-updated', this.__settingsUpdated);
+
+        if (index === undefined) index = this.settings.length;
+        this.settings.splice(index, 0, setting);
+
+        const event = {
+            category: this, category_id: this.id,
+            setting, setting_id: setting.id,
+            at_index: index
+        };
+
+        await setting.emit('added-to', event);
+        await this.emit('added-setting', event);
+        return setting;
+    }
+
+    /**
+     * Dynamically removes a setting from this category.
+     * @param {Setting} setting The setting to remove from this category
+     * @return {Promise}
+     */
+    async removeSetting(setting) {
+        setting.off('setting-updated', this.__settingUpdated);
+        setting.off('settings-updated', this.__settingsUpdated);
+
+        let index;
+        while ((index = this.settings.findIndex(s => s === setting)) > -1) {
+            this.settings.splice(index, 0);
+        }
+
+        const event = {
+            set: this, set_id: this.id,
+            category: this, category_id: this.id,
+            from_index: index
+        };
+
+        await setting.emit('removed-from', event);
+        await this.emit('removed-category', event);
+    }
+
+    /**
+     * Returns a proxy which can be used to access the category's values like a normal object.
+     * @return {SettingsCategoryProxy}
+     */
+    get proxy() {
+        return this._proxy || (this._proxy = SettingsProxy.createProxy(this));
+    }
+
+    /**
+     * Returns the first setting where calling {function} returns true.
+     * @param {Function} function A function to call to filter settings
+     * @return {Setting}
+     */
+    find(f) {
+        return this.settings.find(f);
+    }
+
+    /**
+     * Returns all settings where calling {function} returns true.
+     * @param {Function} function A function to call to filter settings
+     * @return {Array} An array of matching Setting objects
+     */
+    findSettings(f) {
+        return this.settings.filter(f);
+    }
+
+    /**
+     * Returns the setting with the ID {id}.
+     * @param {String} id The ID of the setting to look for
+     * @return {Setting}
+     */
+    getSetting(id) {
+        return this.find(setting => setting.id === id);
+    }
+
+    /**
+     * Merges a category into this category without emitting events (and therefore synchronously).
+     * This only exists for use by the constructor and SettingsSet.
+     */
+    _merge(newCategory) {
+        let updatedSettings = [];
+
+        for (const newSetting of newCategory.settings) {
+            const setting = this.settings.find(setting => setting.id === newSetting.id);
+            if (!setting) {
+                Logger.warn('SettingsCategory', `Trying to merge setting ${this.id}/${newSetting.id}, which does not exist.`);
+                continue;
+            }
+
+            const updatedSetting = setting._merge(newSetting);
+            if (!updatedSetting) continue;
+            updatedSettings = updatedSettings.concat(updatedSetting.map(({ setting, value, old_value }) => ({
+                category: this, category_id: this.id,
+                setting, setting_id: setting.id,
+                value, old_value
+            })));
+        }
+
+        return updatedSettings;
+    }
+
+    /**
+     * Merges another category into this category.
+     * @param {SettingsCategory} newCategory The category to merge into this category
+     * @return {Promise}
+     */
+    async merge(newCategory, emit_multi = true) {
+        let updatedSettings = [];
+
+        for (const newSetting of newCategory.settings) {
+            const setting = this.settings.find(setting => setting.id === newSetting.id);
+            if (!setting) {
+                Logger.warn('SettingsCategory', `Trying to merge setting ${this.id}/${newSetting.id}, which does not exist.`);
+                continue;
+            }
+
+            const updatedSetting = await setting.merge(newSetting, false);
+            if (!updatedSetting) continue;
+            updatedSettings = updatedSettings.concat(updatedSetting.map(({ setting, value, old_value }) => ({
+                category: this, category_id: this.id,
+                setting, setting_id: setting.id,
+                value, old_value
+            })));
+        }
+
+        if (emit_multi)
+            await this.emit('settings-updated', new SettingsUpdatedEvent({
+                updatedSettings
+            }));
+
+        return updatedSettings;
+    }
+
+    /**
+     * Marks all settings in this set as saved (not changed).
+     */
+    setSaved() {
+        for (const setting of this.settings) {
+            setting.setSaved();
+        }
+    }
+
+    /**
+     * Returns an object that can be stored as JSON and later merged back into a category with settingscategory.merge.
+     * @return {Object}
+     */
+    strip() {
+        return {
+            category: this.category,
+            settings: this.settings.map(setting => setting.strip())
+        };
+    }
+
+    /**
+     * Returns a copy of this category that can be changed and then merged back into a set with settingscategory.merge.
+     * @param {SettingsCategory} ...merge A set to merge into the new set
+     * @return {SettingsCategory}
+     */
+    clone(...merge) {
+        return new SettingsCategory({
+            id: this.id,
+            category: this.id,
+            name: this.name,
+            category_name: this.category_name,
+            type: this.type,
+            settings: this.settings.map(setting => setting.clone())
+        }, ...merge);
+    }
+
+}