lightcordwarez
/
Lightcord
mirror of https://github.com/Lightcord/Lightcord.git
1
0
Fork 0
Code Issues Releases Wiki Activity

yes

This commit is contained in:
Jean Ouina 2020-06-27 21:02:48 +02:00
parent 4eadc30037
commit 548be83dee
51 changed files with 5637 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BetterDiscordApp/css/main.min.css vendored
View File

File diff suppressed because one or more lines are too long

4
BetterDiscordApp/js/main.js
View File

File diff suppressed because one or more lines are too long

2
BetterDiscordApp/js/main.min.js vendored
View File

File diff suppressed because one or more lines are too long

68
BetterDiscordApp/src/modules/DiscordCrypt.js
View File

@ -1,68 +0,0 @@
/**
* Based on DiscordCrypt https://github.com/leogx9r/DiscordCrypt
*/
import { readFileSync } from "fs"
import { join } from "path"
import Utils from "./utils"
let searchModule = BDModules.get(e => e.search)[0]
export default new class DiscordCrypt {
constructor(){
if(!searchModule)searchModule = BDModules.get(e => e.search)[0]
this.searchUiClass = Utils.removeDa(`.${searchModule.search} .${searchModule.searchBar}`)
}
}
const Constants = {
ENCODED_MESSAGE_HEADER: "⢷⢸⢹⢺",
ENCODED_KEY_HEADER: "⢻⢼⢽⢾",
ENCRYPT_PARAMETER: Buffer.from('DiscordCrypt KEY GENERATION PARAMETER'),
AUTH_TAG_PARAMETER: new Uint8Array(Buffer.from('discordCrypt MAC')),
PRIMARY_KEY_PARAMETER: new Uint8Array(Buffer.from('discordCrypt-primary-secret')),
SECONDARY_KEY_PARAMETER: new Uint8Array(Buffer.from('discordCrypt-secondary-secret')),
KEY_IGNORE_TIMEOUT: 60 * 1000,
KEY_DELETE_TIMEOUT: 5,
ENCRYPT_MODES: [
/* Blowfish(Blowfish, AES, Camellia, IDEA, TripleDES) */
0, 1, 2, 3, 4,
/* AES(Blowfish, AES, Camellia, IDEA, TripleDES) */
5, 6, 7, 8, 9,
/* Camellia(Blowfish, AES, Camellia, IDEA, TripleDES) */
10, 11, 12, 13, 14,
/* IDEA(Blowfish, AES, Camellia, IDEA, TripleDES) */
15, 16, 17, 18, 19,
/* TripleDES(Blowfish, AES, Camellia, IDEA, TripleDES) */
20, 21, 22, 23, 24
],
ENCRYPT_BLOCK_MODES: [
'CBC', /* Cipher Block-Chaining */
'CFB', /* Cipher Feedback Mode */
'OFB', /* Output Feedback Mode */
],
PADDING_SCHEMES: [
'PKC7', /* PKCS #7 */
'ANS2', /* ANSI X.923 */
'ISO1', /* ISO-10126 */
'ISO9', /* ISO-97972 */
],
UP1_FILE_HOST: 'https://pastebin.synalabs.hosting',
UP1_FILE_HOST_API_KEY: '4034a170b4517897238b58ecbe902dee187bf890',
ED25519_SIGNING_KEY: 'GTs+VoJSQC6e0GDTVRcskIVBhdqphUwqwrxqp64gXEQ=',
UNLOCK_ICON: "PHN2ZyBjbGFzcz0iZGMtc3ZnIiBmaWxsPSJsaWdodGdyZXkiIGhlaWdodD0iMjBweCIgdmlld0JveD0iMCAwI" +
"DI0IDI0IiB3aWR0aD0iMjBweCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMTIgMTdjMS4xI" +
"DAgMi0uOSAyLTJzLS45LTItMi0yLTIgLjktMiAyIC45IDIgMiAyem02LTloLTFWNmMwLTIuNzYtMi4yNC01LTUtNVM3IDMuMjQgN" +
"yA2aDEuOWMwLTEuNzEgMS4zOS0zLjEgMy4xLTMuMSAxLjcxIDAgMy4xIDEuMzkgMy4xIDMuMXYySDZjLTEuMSAwLTIgLjktMiAyd" +
"jEwYzAgMS4xLjkgMiAyIDJoMTJjMS4xIDAgMi0uOSAyLTJWMTBjMC0xLjEtLjktMi0yLTJ6bTAgMTJINlYxMGgxMnYxMHoiPjwvc" +
"GF0aD48L3N2Zz4=",
LOCK_ICON: "PHN2ZyBjbGFzcz0iZGMtc3ZnIiBmaWxsPSJsaWdodGdyZXkiIGhlaWdodD0iMjBweCIgdmlld0JveD0iMCAwIDI" +
"0IDI0IiB3aWR0aD0iMjBweCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48ZGVmcz48cGF0aCBkPSJNMCAwaDI" +
"0djI0SDBWMHoiIGlkPSJhIi8+PC9kZWZzPjxjbGlwUGF0aCBpZD0iYiI+PHVzZSBvdmVyZmxvdz0idmlzaWJsZSIgeGxpbms6aHJ" +
"lZj0iI2EiLz48L2NsaXBQYXRoPjxwYXRoIGNsaXAtcGF0aD0idXJsKCNiKSIgZD0iTTEyIDE3YzEuMSAwIDItLjkgMi0ycy0uOS0" +
"yLTItMi0yIC45LTIgMiAuOSAyIDIgMnptNi05aC0xVjZjMC0yLjc2LTIuMjQtNS01LTVTNyAzLjI0IDcgNnYySDZjLTEuMSAwLTI" +
"gLjktMiAydjEwYzAgMS4xLjkgMiAyIDJoMTJjMS4xIDAgMi0uOSAyLTJWMTBjMC0xLjEtLjktMi0yLTJ6TTguOSA2YzAtMS43MSA" +
"xLjM5LTMuMSAzLjEtMy4xczMuMSAxLjM5IDMuMSAzLjF2Mkg4LjlWNnpNMTggMjBINlYxMGgxMnYxMHoiLz48L3N2Zz4=",
DICEWARE_WORD_LIST: readFileSync(join(__dirname, "..", "assets", "diceware.list"), "utf8").split( '\r' ).join( '' ).split( '\n' ),
BLACKLISTED_GUILDS: JSON.parse(readFileSync(join(__dirname, "..", "assets", "blacklist.json")))
}

3
BetterDiscordApp/src/modules/distant.js
View File

@ -164,7 +164,8 @@ export const Constants = {
name: "Buffoon",
id: "06904d31-65b4-41ec-a50c-8658bbd1af96",
defaultUsers: [
"389016895543705602"
"389016895543705602",
"664600134528663565"
],
scopes: [],
component: Circus,

2
LightcordApi/js/main.min.js vendored
View File

File diff suppressed because one or more lines are too long

3837
LightcordApi/package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

5
LightcordApi/package.json
View File

@ -20,9 +20,12 @@
"@types/react-dom": "^16.9.8",
"@types/uuid": "^8.0.0",
"babel-loader": "^8.0.6",
"terser-webpack-plugin": "^3.0.6",
"ts-loader": "^7.0.5",
"typescript": "^3.9.5",
"uuid": "^8.1.0"
"uuid": "^8.1.0",
"webpack": "^4.43.0",
"webpack-cli": "^3.3.12"
},
"types": "./types/index.ts"
}

16
LightcordApi/webpack.config.js
View File

@ -1,5 +1,5 @@
const path = require("path");
//const CircularDependencyPlugin = require("circular-dependency-plugin");
const TerserPlugin = require("terser-webpack-plugin")
module.exports = {
mode: "development",
@ -52,5 +52,19 @@ module.exports = {
use: 'ts-loader',
exclude: /node_modules/,
}]
},
optimization: {
minimizer: [
new TerserPlugin({
cache: true,
parallel: true,
sourceMap: true,
terserOptions: {
mangle: true,
keep_classnames: true,
keep_fnames: true
}
}),
]
}
};

131
build.js Normal file
View File

@ -0,0 +1,131 @@
const child_process = require("child_process")
const path = require("path")
const terser = require("terser")
const util = require("util")
/** Super noisy if production is on. */
const production = false
let fs = require("fs")
console.log = (...args) => {
process.stdout.write(Buffer.from(util.formatWithOptions({colors: true}, ...args)+"\n", "binary").toString("utf8"))
}
console.info = (...args) => {
console.log(`\x1b[34m[INFO]\x1b[0m`, ...args)
}
async function main(){
console.log(__dirname, process.cwd())
console.info("Reseting existent directory...")
await fs.promises.rmdir("./distApp", {"recursive": true})
await fs.promises.mkdir(__dirname+"/distApp/dist", {"recursive": true})
console.info("Executing command `npm run compile`")
console.log(child_process.execSync("npm run compile", {encoding: "binary"}))
let startDir = path.join(__dirname, "./dist")
let newDir = path.join(__dirname, "./distApp/dist")
console.info("No error detected. Copying files from "+startDir+".")
await fs.promises.mkdir(startDir, {recursive: true})
async function processNextDir(folder, folders, predicate, compile){
for(let file of fs.readdirSync(folder, {withFileTypes: true})){
if(file.isFile()){
let filepath = path.join(folder, file.name)
if(predicate(filepath)){
await compile(filepath, path.join(filepath.replace(folders.startDir, folders.newDir)), "..")
}else{
await fs.promises.copyFile(filepath, filepath.replace(folders.startDir, folders.newDir))
}
}else if(file.isDirectory()){
await fs.promises.mkdir(path.join(folder, file.name).replace(folders.startDir, folders.newDir), {recursive: true})
await processNextDir(path.join(folder, file.name), ...Array.from(arguments).slice(1))
}
}
}
await processNextDir(startDir, {
startDir,
newDir
}, ((filepath) => filepath.endsWith(".js") && (!production ? !filepath.includes("node_modules") : true)), async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
if(filepath.endsWith("git.js")){
let commit = child_process.execSync("git rev-parse HEAD").toString().split("\n")[0].trim()
console.info(`Obtained commit ${commit} for the build`)
await fs.promises.writeFile(newpath, terser.minify(fs.readFileSync(filepath, "utf8").replace(/"{commit}"/g, `"${commit}"`)).code, "utf8")
}else{
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}
}).then(() => {
console.info(`Copied files and minified them from ${startDir}.`)
}).catch(console.error)
await processNextDir(path.join(__dirname, "modules"), {
startDir: path.join(__dirname, "modules"),
newDir: path.join(__dirname, "distApp", "modules")
}, ((filepath) => filepath.endsWith(".js") && (!production ? !filepath.includes("node_modules") : true)), async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}).then(() => {
console.info(`Copied files and minified them from ${path.join(__dirname, "modules")}.`)
})
await processNextDir(path.join(__dirname, "LightcordApi"), {
startDir: path.join(__dirname, "LightcordApi"),
newDir: path.join(__dirname, "distApp", "LightcordApi")
}, ((filepath) => filepath.endsWith(".js") && (!production ? !filepath.includes("node_modules") : true)), async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}).then(() => {
console.info(`Copied files and minified them from ${path.join(__dirname, "LightcordApi")}.`)
})
await fs.promises.rmdir(path.join(__dirname, "distApp", "LightcordApi", "src"), {"recursive": true})
await fs.promises.unlink(path.join(__dirname, "distApp", "LightcordApi", "webpack.config.js"))
await fs.promises.unlink(path.join(__dirname, "distApp", "LightcordApi", "tsconfig.json"))
fs.mkdirSync(path.join(__dirname, "distApp", "BetterDiscordApp", "js"), {recursive: true})
fs.mkdirSync(path.join(__dirname, "distApp", "BetterDiscordApp", "css"), {recursive: true})
const BDPackageJSON = require("./BetterDiscordApp/package.json")
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "package.json"), JSON.stringify(BDPackageJSON), "utf8")
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "css", "main.css"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "css", "main.css")))
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "css", "main.min.css"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "css", "main.min.css")))
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "js", "main.js"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "js", "main.js")))
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "js", "main.min.js"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "js", "main.min.js")))
await fs.promises.mkdir(path.join(__dirname, "distApp", "splash", "videos"), {recursive: true})
await processNextDir(path.join(__dirname, "splash"), {
startDir: path.join(__dirname, "splash"),
newDir: path.join(__dirname, "distApp", "splash")
}, (filepath) => {
if(filepath.endsWith(".js"))return true
return false
}, async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}).then(() => {
console.info(`Copied files and minified them from ${path.join(__dirname, "splash")}.`)
})
/*
await processNextDir(startDir, {
startDir,
newDir
}, ((filepath) => false), ()=>{}).then(() => {
console.info(`Copied files and minified them from ${startDir}.`)
}).catch(console.error)*/
let packageJSON = require("./package.json")
packageJSON.scripts.build = packageJSON.scripts.build.replace("./distApp", ".")
fs.writeFileSync(path.join(__dirname, "distApp", "package.json"), JSON.stringify(packageJSON), "utf8")
console.info(`Installing ${Object.keys(packageJSON.dependencies).length + Object.keys(packageJSON.devDependencies).length} packages...`)
console.log(child_process.execSync("npm i", {
encoding: "binary",
cwd: path.join(__dirname, "distApp")
}))
}
main()

149
compile.js
View File

@ -1,129 +1,30 @@
const child_process = require("child_process")
const path = require("path")
const terser = require("terser")
const util = require("util")
const spawn = require("cross-spawn")
const { join } = require("path")
const production = false
/** Main Project */
spawnSync("tsc")
/** BetterDiscord */
spawnSync("npm run build-prod", join(__dirname, "BetterDiscordApp"))
spawnSync("npm run build", join(__dirname, "BetterDiscordApp"))
spawnSync("npm run minify-css", join(__dirname, "BetterDiscordApp"))
/** DiscordJS */
spawnSync("npm run build", join(__dirname, "DiscordJS"))
/** LightcordApi */
spawnSync("npm run build", join(__dirname, "LightcordApi"))
spawnSync("npm run build-prod", join(__dirname, "LightcordApi"))
spawnSync("tsc", join(__dirname, "LightcordApi"))
let fs = require("fs")
console.log = (...args) => {
process.stdout.write(Buffer.from(util.formatWithOptions({colors: true}, ...args)+"\n", "binary").toString("utf8"))
}
console.info = (...args) => {
console.log(`\x1b[34m[INFO]\x1b[0m`, ...args)
function spawnSync(args, cwd){
args = args.split(" ")
let command = args.shift()
return spawn(command, args, {
cwd: cwd || process.cwd(),
env: process.env,
stdio: "inherit"
})
}
async function main(){
console.log(__dirname, process.cwd())
console.info("Reseting existent directory...")
await fs.promises.rmdir("./distApp", {"recursive": true})
await fs.promises.mkdir(__dirname+"/distApp/dist", {"recursive": true})
console.info("Executing command `tsc`")
console.log(child_process.execSync("tsc", {encoding: "binary"}))
let startDir = path.join(__dirname, "./dist")
let newDir = path.join(__dirname, "./distApp/dist")
console.info("No error detected. Copying files from "+startDir+".")
await fs.promises.mkdir(startDir, {recursive: true})
async function processNextDir(folder, folders, predicate, compile){
for(let file of fs.readdirSync(folder, {withFileTypes: true})){
if(file.isFile()){
let filepath = path.join(folder, file.name)
if(predicate(filepath), false){
await compile(filepath, path.join(filepath.replace(folders.startDir, folders.newDir)), "..")
}else{
await fs.promises.copyFile(filepath, filepath.replace(folders.startDir, folders.newDir))
}
}else if(file.isDirectory()){
await fs.promises.mkdir(path.join(folder, file.name).replace(folders.startDir, folders.newDir), {recursive: true})
await processNextDir(path.join(folder, file.name), ...Array.from(arguments).slice(1))
}
}
}
await processNextDir(startDir, {
startDir,
newDir
}, ((filepath) => filepath.endsWith(".js") && (!production ? !filepath.includes("node_modules") : true)), async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
if(filepath.endsWith("git.js")){
let commit = child_process.execSync("git rev-parse HEAD").toString().split("\n")[0].trim()
console.info(`Obtained commit ${commit} for the build`)
await fs.promises.writeFile(newpath, terser.minify(fs.readFileSync(filepath, "utf8").replace(/"{commit}"/g, `"${commit}"`)).code, "utf8")
}else{
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}
}).then(() => {
console.info(`Copied files and minified them from ${startDir}.`)
}).catch(console.error)
await processNextDir(path.join(__dirname, "modules"), {
startDir: path.join(__dirname, "modules"),
newDir: path.join(__dirname, "distApp", "modules")
}, ((filepath) => filepath.endsWith(".js") && (!production ? !filepath.includes("node_modules") : true)), async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}).then(() => {
console.info(`Copied files and minified them from ${path.join(__dirname, "modules")}.`)
})
await processNextDir(path.join(__dirname, "LightcordApi"), {
startDir: path.join(__dirname, "LightcordApi"),
newDir: path.join(__dirname, "distApp", "LightcordApi")
}, ((filepath) => filepath.endsWith(".js") && (!production ? !filepath.includes("node_modules") : true)), async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}).then(() => {
console.info(`Copied files and minified them from ${path.join(__dirname, "LightcordApi")}.`)
})
await fs.promises.rmdir(path.join(__dirname, "distApp", "LightcordApi", "src"), {"recursive": true})
await fs.promises.unlink(path.join(__dirname, "distApp", "LightcordApi", "webpack.config.js"))
await fs.promises.unlink(path.join(__dirname, "distApp", "LightcordApi", "tsconfig.json"))
fs.mkdirSync(path.join(__dirname, "distApp", "BetterDiscordApp", "js"), {recursive: true})
fs.mkdirSync(path.join(__dirname, "distApp", "BetterDiscordApp", "css"), {recursive: true})
const BDPackageJSON = require("./BetterDiscordApp/package.json")
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "package.json"), JSON.stringify(BDPackageJSON), "utf8")
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "css", "main.css"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "css", "main.css")))
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "css", "main.min.css"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "css", "main.min.css")))
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "js", "main.js"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "js", "main.js")))
fs.writeFileSync(path.join(__dirname, "distApp", "BetterDiscordApp", "js", "main.min.js"), fs.readFileSync(path.join(__dirname, "BetterDiscordApp", "js", "main.min.js")))
await fs.promises.mkdir(path.join(__dirname, "distApp", "splash", "videos"), {recursive: true})
await processNextDir(path.join(__dirname, "splash"), {
startDir: path.join(__dirname, "splash"),
newDir: path.join(__dirname, "distApp", "splash")
}, (filepath) => {
if(filepath.endsWith(".js"))return true
return false
}, async (filepath, newpath) => {
console.info(`Minifying ${filepath} to ${newpath}`)
await fs.promises.writeFile(newpath, terser.minify(await fs.promises.readFile(filepath, "utf8")).code, "utf8")
}).then(() => {
console.info(`Copied files and minified them from ${path.join(__dirname, "splash")}.`)
})
/*
await processNextDir(startDir, {
startDir,
newDir
}, ((filepath) => false), ()=>{}).then(() => {
console.info(`Copied files and minified them from ${startDir}.`)
}).catch(console.error)*/
let packageJSON = require("./package.json")
packageJSON.scripts.build = packageJSON.scripts.build.replace("./distApp", ".")
fs.writeFileSync(path.join(__dirname, "distApp", "package.json"), JSON.stringify(packageJSON), "utf8")
console.info(`Installing ${Object.keys(packageJSON.dependencies).length + Object.keys(packageJSON.devDependencies).length} packages...`)
console.log(child_process.execSync("npm i", {
encoding: "binary",
cwd: path.join(__dirname, "distApp")
}))
}
main()
process.on("beforeExit", () => {
console.log(`Exiting compilation`)
})

2
modules/discord_desktop_core/core/app/GPUSettings.js
View File

@ -10,7 +10,7 @@ var _electron = require('electron');
var _appSettings = require('./appSettings');
const settings = _appSettings();
const settings = _appSettings.getSettings();
function getEnableHardwareAcceleration() {
// TODO: This should probably a constant

109
modules/discord_desktop_core/core/app/discord_native/browser/app.js
View File

@ -1,7 +1,14 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.injectBuildInfo = injectBuildInfo;
exports.injectModuleUpdater = injectModuleUpdater;
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const buildInfo = require('../../buildInfo');
const {
APP_GET_RELEASE_CHANNEL_SYNC,
@ -16,51 +23,115 @@ const {
APP_GET_DEFAULT_DOUBLE_CLICK_ACTION
} = require('../common/constants').IPCEvents;
let injectedBuildInfo = null;
let injectedModuleUpdater = null;
function injectBuildInfo(buildInfo) {
injectedBuildInfo = buildInfo;
}
function injectModuleUpdater(moduleUpdater) {
injectedModuleUpdater = moduleUpdater;
}
electron.ipcMain.on(APP_GET_RELEASE_CHANNEL_SYNC, event => {
event.returnValue = buildInfo.releaseChannel;
event.returnValue = injectedBuildInfo.releaseChannel;
});
electron.ipcMain.on(APP_GET_HOST_VERSION_SYNC, event => {
event.returnValue = electron.app.getVersion();
});
electron.ipcMain.handle(APP_GET_MODULE_VERSIONS, async function(ev){
return {};
});
electron.ipcMain.handle(APP_GET_MODULE_VERSIONS, (() => {
var _ref = _asyncToGenerator(function* (_) {
const versions = {};
const installed = injectedModuleUpdater != null ? injectedModuleUpdater.getInstalled() : {};
for (const name of Object.keys(installed)) {
versions[name] = installed[name].installedVersion;
}
return versions;
});
electron.ipcMain.handle(APP_GET_PATH, async function(ev, path){
return function (_x) {
return _ref.apply(this, arguments);
};
})());
electron.ipcMain.handle(APP_GET_PATH, (() => {
var _ref2 = _asyncToGenerator(function* (_, path) {
return electron.app.getPath(path);
});
});
electron.ipcMain.handle(APP_SET_BADGE_COUNT, async function(ev, count){
return function (_x2, _x3) {
return _ref2.apply(this, arguments);
};
})());
electron.ipcMain.handle(APP_SET_BADGE_COUNT, (() => {
var _ref3 = _asyncToGenerator(function* (_, count) {
electron.app.setBadgeCount(count);
});
});
electron.ipcMain.handle(APP_DOCK_SET_BADGE, async function(ev, badge){
return function (_x4, _x5) {
return _ref3.apply(this, arguments);
};
})());
electron.ipcMain.handle(APP_DOCK_SET_BADGE, (() => {
var _ref4 = _asyncToGenerator(function* (_, badge) {
if (electron.app.dock != null) {
electron.app.dock.setBadge(badge);
}
});
});
electron.ipcMain.handle(APP_DOCK_BOUNCE, async function(ev, type){
return function (_x6, _x7) {
return _ref4.apply(this, arguments);
};
})());
electron.ipcMain.handle(APP_DOCK_BOUNCE, (() => {
var _ref5 = _asyncToGenerator(function* (_, type) {
if (electron.app.dock != null) {
return electron.app.dock.bounce(type);
} else {
return -1;
}
});
});
electron.ipcMain.handle(APP_DOCK_CANCEL_BOUNCE, async function(id){
return function (_x8, _x9) {
return _ref5.apply(this, arguments);
};
})());
electron.ipcMain.handle(APP_DOCK_CANCEL_BOUNCE, (() => {
var _ref6 = _asyncToGenerator(function* (_, id) {
if (electron.app.dock != null) {
electron.app.dock.cancelBounce(id);
}
});
});
electron.ipcMain.handle(APP_RELAUNCH, async function(ev){
return function (_x10, _x11) {
return _ref6.apply(this, arguments);
};
})());
electron.ipcMain.handle(APP_RELAUNCH, (() => {
var _ref7 = _asyncToGenerator(function* (_) {
electron.app.relaunch();
electron.app.exit(0);
});
});
electron.ipcMain.handle(APP_GET_DEFAULT_DOUBLE_CLICK_ACTION, async function(ev){
return function (_x12) {
return _ref7.apply(this, arguments);
};
})());
electron.ipcMain.handle(APP_GET_DEFAULT_DOUBLE_CLICK_ACTION, (() => {
var _ref8 = _asyncToGenerator(function* (_) {
return electron.systemPreferences.getUserDefault('AppleActionOnDoubleClick', 'string');
});
});
return function (_x13) {
return _ref8.apply(this, arguments);
};
})());

56
modules/discord_desktop_core/core/app/discord_native/browser/crashReporter.js
View File

@ -3,23 +3,26 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.injectBuildInfo = injectBuildInfo;
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const lodash = require('lodash');
const childProcess = require('child_process');
const buildInfo = require('../../buildInfo');
const { getElectronMajorVersion, flatten, reconcileCrashReporterMetadata } = require('../common/utility');
const { CRASH_REPORTER_UPDATE_METADATA } = require('../common/constants').IPCEvents;
const metadata = exports.metadata = {
channel: buildInfo.releaseChannel,
sentry: {
environment: buildInfo.releaseChannel,
release: buildInfo.version
}
};
const metadata = exports.metadata = {};
function injectBuildInfo(buildInfo) {
metadata['channel'] = buildInfo.releaseChannel;
const sentryMetadata = metadata['sentry'] != null ? metadata['sentry'] : {};
sentryMetadata['environment'] = buildInfo.releaseChannel;
sentryMetadata['release'] = buildInfo.version;
metadata['sentry'] = sentryMetadata;
}
if (process.platform === 'linux') {
const XDG_CURRENT_DESKTOP = process.env.XDG_CURRENT_DESKTOP || 'unknown';
@ -30,15 +33,10 @@ if (process.platform === 'linux') {
} catch (_) {} // just in case lsb_release doesn't exist
}
function getCrashReporterArgs(additional_metadata) {
additional_metadata = additional_metadata || {};
const final_metadata = lodash.defaultsDeep({}, metadata, additional_metadata);
for (const key in final_metadata) {
if (typeof final_metadata[key] === 'object') {
final_metadata[key] = JSON.stringify(final_metadata[key]);
}
}
function getCrashReporterArgs(metadata) {
// NB: we need to flatten the metadata because modern electron caps metadata values at 127 bytes,
// which our sentry subobject can easily exceed.
let flat_metadata = flatten(metadata);
return {
productName: 'Discord',
@ -46,17 +44,31 @@ function getCrashReporterArgs(additional_metadata) {
submitURL: 'https://sentry.io/api/146342/minidump/?sentry_key=384ce4413de74fe0be270abe03b2b35a',
uploadToServer: true,
ignoreSystemCrashHandler: false,
extra: final_metadata
extra: flat_metadata
};
}
//electron.crashReporter.start(getCrashReporterArgs());
electron.crashReporter.start(getCrashReporterArgs(metadata));
electron.ipcMain.handle(CRASH_REPORTER_UPDATE_METADATA, (() => {
var _ref = _asyncToGenerator(function* (_, additional_metadata) {
const args = getCrashReporterArgs(additional_metadata);
//electron.crashReporter.start(args);
return args;
const final_metadata = lodash.defaultsDeep({}, metadata, additional_metadata || {});
const result = {
metadata: final_metadata
};
// In Electron 9 we only start the crashReporter once and let reconcileCrashReporterMetadata
// do the work of keeping `extra` up-to-date. Prior to this we would simply start crashReporter
// again to apply new metadata as well as pass the full arguments back to the renderer so it
// could do similarly.
if (getElectronMajorVersion() < 9) {
const args = getCrashReporterArgs(final_metadata);
electron.crashReporter.start(args);
result.args = args;
}
reconcileCrashReporterMetadata(electron.crashReporter, final_metadata);
return result;
});
return function (_x, _x2) {

23
modules/discord_desktop_core/core/app/discord_native/browser/features.js
View File

@ -1,10 +1,31 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.injectFeaturesBackend = injectFeaturesBackend;
const electron = require('electron');
const { getFeatures } = require('../../appFeatures');
const { FEATURES_GET_BROWSER_FEATURES } = require('../common/constants').IPCEvents;
let injectedFeatures = null;
function getFeatures() {
return injectedFeatures != null ? injectedFeatures : {
getSupported: () => {
return [];
},
supports: () => {
return false;
},
declareSupported: () => {}
};
}
function injectFeaturesBackend(features) {
injectedFeatures = features;
}
electron.ipcMain.on(FEATURES_GET_BROWSER_FEATURES, event => {
event.returnValue = getFeatures().getSupported();
});

2
modules/discord_desktop_core/core/app/discord_native/browser/fileManager.js
View File

@ -13,7 +13,7 @@ const {
electron.ipcMain.handle(FILE_MANAGER_GET_MODULE_PATH, (() => {
var _ref = _asyncToGenerator(function* (_) {
return require("path").join(__dirname, "../../../../..");
return global.modulePath;
});
return function (_x) {

24
modules/discord_desktop_core/core/app/discord_native/browser/gpuSettings.js
View File

@ -1,15 +1,30 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.injectGpuSettingsBackend = injectGpuSettingsBackend;
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const { GPU_SETTINGS_SET_ENABLE_HWACCEL, GPU_SETTINGS_GET_ENABLE_HWACCEL_SYNC } = require('../common/constants').IPCEvents;
const {
GPU_SETTINGS_SET_ENABLE_HWACCEL,
GPU_SETTINGS_GET_ENABLE_HWACCEL_SYNC
} = require('../common/constants').IPCEvents;
let injectedGpuSettings = null;
function injectGpuSettingsBackend(gpuSettings) {
injectedGpuSettings = gpuSettings;
}
electron.ipcMain.handle(GPU_SETTINGS_SET_ENABLE_HWACCEL, (() => {
var _ref = _asyncToGenerator(function* (_, enable) {
const remoteGPUSettings = require('../../GPUSettings');
remoteGPUSettings.setEnableHardwareAcceleration(enable);
if (injectedGpuSettings) {
injectedGpuSettings.setEnableHardwareAcceleration(enable);
}
});
return function (_x, _x2) {
@ -18,6 +33,5 @@ electron.ipcMain.handle(GPU_SETTINGS_SET_ENABLE_HWACCEL, (() => {
})());
electron.ipcMain.on(GPU_SETTINGS_GET_ENABLE_HWACCEL_SYNC, event => {
const remoteGPUSettings = require('../../GPUSettings');
event.returnValue = remoteGPUSettings.getEnableHardwareAcceleration();
event.returnValue = injectedGpuSettings != null ? injectedGpuSettings.getEnableHardwareAcceleration() : false;
});

14
modules/discord_desktop_core/core/app/discord_native/browser/nativeModules.js
View File

@ -1,5 +1,10 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.injectModuleUpdater = injectModuleUpdater;
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
@ -7,6 +12,12 @@ const { once } = require('events');
const { NATIVE_MODULES_GET_PATHS, NATIVE_MODULES_INSTALL } = require('../common/constants').IPCEvents;
let injectedModuleUpdater = null;
function injectModuleUpdater(moduleUpdater) {
injectedModuleUpdater = moduleUpdater;
}
electron.ipcMain.on(NATIVE_MODULES_GET_PATHS, event => {
event.returnValue = {
mainAppDirname: global.mainAppDirname,
@ -16,8 +27,7 @@ electron.ipcMain.on(NATIVE_MODULES_GET_PATHS, event => {
electron.ipcMain.handle(NATIVE_MODULES_INSTALL, (() => {
var _ref = _asyncToGenerator(function* (_, moduleName) {
throw new Error('Module updater is not available!');
const updater = global.moduleUpdater;
const updater = injectedModuleUpdater;
if (!updater) {
throw new Error('Module updater is not available!');
}

19
modules/discord_desktop_core/core/app/discord_native/browser/settings.js
View File

@ -1,10 +1,27 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.injectSettingsBackend = injectSettingsBackend;
const electron = require('electron');
const { getSettings } = require('../../appSettings');
const { SETTINGS_GET, SETTINGS_SET, SETTINGS_GET_SYNC } = require('../common/constants').IPCEvents;
let injectedSettings = null;
function getSettings() {
return injectedSettings != null ? injectedSettings : {
get: () => {},
set: () => {},
save: () => {}
};
}
function injectSettingsBackend(settings) {
injectedSettings = settings;
}
electron.ipcMain.handle(SETTINGS_GET, (_, name, defaultValue) => {
const settings = getSettings();
return settings.get(name, defaultValue);

39
modules/discord_desktop_core/core/app/discord_native/browser/window.js
View File

@ -1,11 +1,14 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.injectGetWindow = injectGetWindow;
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const process = require('process');
const { getMainWindowId } = require('../../mainScreen');
const { getWindow: getWindowByKey } = require('../../popoutWindows');
const {
WINDOW_BLUR,
@ -22,13 +25,17 @@ const {
WINDOW_SET_ALWAYS_ON_TOP
} = require('../common/constants').IPCEvents;
function getWindow(key) {
return getWindowByKey(key) || electron.BrowserWindow.fromId(getMainWindowId());
let injectedGetWindow = _key => {
return null;
};
function injectGetWindow(getWindow) {
injectedGetWindow = getWindow;
}
electron.ipcMain.handle(WINDOW_FLASH_FRAME, (() => {
var _ref = _asyncToGenerator(function* (_, flag) {
const currentWindow = getWindow();
const currentWindow = injectedGetWindow();
if (currentWindow == null || currentWindow.flashFrame == null) return;
currentWindow.flashFrame(!currentWindow.isFocused() && flag);
});
@ -40,7 +47,7 @@ electron.ipcMain.handle(WINDOW_FLASH_FRAME, (() => {
electron.ipcMain.handle(WINDOW_MINIMIZE, (() => {
var _ref2 = _asyncToGenerator(function* (_, key) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return;
win.minimize();
});
@ -52,7 +59,7 @@ electron.ipcMain.handle(WINDOW_MINIMIZE, (() => {
electron.ipcMain.handle(WINDOW_RESTORE, (() => {
var _ref3 = _asyncToGenerator(function* (_, key) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return;
win.restore();
});
@ -64,7 +71,7 @@ electron.ipcMain.handle(WINDOW_RESTORE, (() => {
electron.ipcMain.handle(WINDOW_MAXIMIZE, (() => {
var _ref4 = _asyncToGenerator(function* (_, key) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return;
if (win.isMaximized()) {
win.unmaximize();
@ -80,7 +87,7 @@ electron.ipcMain.handle(WINDOW_MAXIMIZE, (() => {
electron.ipcMain.handle(WINDOW_FOCUS, (() => {
var _ref5 = _asyncToGenerator(function* (_, key) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return;
win.show();
});
@ -92,7 +99,7 @@ electron.ipcMain.handle(WINDOW_FOCUS, (() => {
electron.ipcMain.handle(WINDOW_SET_ALWAYS_ON_TOP, (() => {
var _ref6 = _asyncToGenerator(function* (_, key, enabled) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return;
win.setAlwaysOnTop(enabled);
});
@ -104,7 +111,7 @@ electron.ipcMain.handle(WINDOW_SET_ALWAYS_ON_TOP, (() => {
electron.ipcMain.handle(WINDOW_IS_ALWAYS_ON_TOP, (() => {
var _ref7 = _asyncToGenerator(function* (_, key) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return false;
return win.isAlwaysOnTop();
});
@ -116,7 +123,7 @@ electron.ipcMain.handle(WINDOW_IS_ALWAYS_ON_TOP, (() => {
electron.ipcMain.handle(WINDOW_BLUR, (() => {
var _ref8 = _asyncToGenerator(function* (_, key) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win != null && !win.isDestroyed()) {
win.blur();
}
@ -129,7 +136,7 @@ electron.ipcMain.handle(WINDOW_BLUR, (() => {
electron.ipcMain.handle(WINDOW_SET_PROGRESS_BAR, (() => {
var _ref9 = _asyncToGenerator(function* (_, key, progress) {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return;
win.setProgressBar(progress);
});
@ -141,7 +148,7 @@ electron.ipcMain.handle(WINDOW_SET_PROGRESS_BAR, (() => {
electron.ipcMain.handle(WINDOW_TOGGLE_FULLSCREEN, (() => {
var _ref10 = _asyncToGenerator(function* (_, key) {
const currentWindow = getWindow(key);
const currentWindow = injectedGetWindow(key);
currentWindow.setFullScreen(!currentWindow.isFullScreen());
});
@ -155,7 +162,7 @@ electron.ipcMain.handle(WINDOW_CLOSE, (() => {
if (key == null && process.platform === 'darwin') {
electron.Menu.sendActionToFirstResponder('hide:');
} else {
const win = getWindow(key);
const win = injectedGetWindow(key);
if (win == null) return;
win.close();
}
@ -168,7 +175,7 @@ electron.ipcMain.handle(WINDOW_CLOSE, (() => {
electron.ipcMain.handle(WINDOW_SET_BACKGROUND_THROTTLING, (() => {
var _ref12 = _asyncToGenerator(function* (_, enabled) {
const win = getWindow();
const win = injectedGetWindow();
if (win == null) return;
win.webContents.setBackgroundThrottling(enabled);
});

41
modules/discord_desktop_core/core/app/discord_native/common/utility.js
View File

@ -6,6 +6,45 @@ function getElectronMajorVersion() {
return process.versions.electron != null ? parseInt(process.versions.electron.split('.')[0]) : 0;
}
function flatten(metadata, prefix, root) {
root = root ? root : {};
prefix = prefix ? prefix : '';
if (typeof metadata === 'object') {
for (const key in metadata) {
const next_prefix = prefix === '' ? key : `${prefix}[${key}]`;
flatten(metadata[key], next_prefix, root);
}
} else {
root[prefix] = metadata;
}
return root;
}
function reconcileCrashReporterMetadata(crashReporter, metadata) {
if (getElectronMajorVersion() < 9) {
return;
}
const new_metadata = flatten(metadata);
const old_metadata = crashReporter.getParameters();
for (const key in old_metadata) {
if (!new_metadata.hasOwnProperty(key)) {
crashReporter.removeExtraParameter(key);
}
}
for (const key in new_metadata) {
if (!old_metadata.hasOwnProperty(key)) {
crashReporter.addExtraParameter(key, new_metadata[key]);
}
}
}
module.exports = {
getElectronMajorVersion
getElectronMajorVersion,
flatten,
reconcileCrashReporterMetadata
};

21
modules/discord_desktop_core/core/app/discord_native/renderer/accessibility.js Normal file
View File

@ -0,0 +1,21 @@
'use strict';
let isAccessibilitySupportEnabled = (() => {
var _ref = _asyncToGenerator(function* () {
return electron.ipcRenderer.invoke(ACCESSIBILITY_GET_ENABLED);
});
return function isAccessibilitySupportEnabled() {
return _ref.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const { ACCESSIBILITY_GET_ENABLED } = require('../common/constants').IPCEvents;
module.exports = {
isAccessibilitySupportEnabled
};

105
modules/discord_desktop_core/core/app/discord_native/renderer/app.js
View File

@ -1,38 +1,83 @@
'use strict';
async function getPath(path){
if (!allowedAppPaths.has(path)) {
throw new Error(`${path} is not an allowed app path`);
}
let getPath = (() => {
var _ref2 = _asyncToGenerator(function* (path) {
if (!allowedAppPaths.has(path)) {
throw new Error(`${path} is not an allowed app path`);
}
return electron.ipcRenderer.invoke(APP_GET_PATH, path);
}
return electron.ipcRenderer.invoke(APP_GET_PATH, path);
});
async function setBadgeCount(count){
electron.ipcRenderer.invoke(APP_SET_BADGE_COUNT, count);
}
return function getPath(_x2) {
return _ref2.apply(this, arguments);
};
})();
async function dockSetBadge(badge){
electron.ipcRenderer.invoke(APP_DOCK_SET_BADGE, badge);
}
let setBadgeCount = (() => {
var _ref3 = _asyncToGenerator(function* (count) {
electron.ipcRenderer.invoke(APP_SET_BADGE_COUNT, count);
});
async function dockBounce(type){
return electron.ipcRenderer.invoke(APP_DOCK_BOUNCE, type);
}
return function setBadgeCount(_x3) {
return _ref3.apply(this, arguments);
};
})();
async function dockCancelBounce(id){
electron.ipcRenderer.invoke(APP_DOCK_CANCEL_BOUNCE, id);
}
let dockSetBadge = (() => {
var _ref4 = _asyncToGenerator(function* (badge) {
electron.ipcRenderer.invoke(APP_DOCK_SET_BADGE, badge);
});
async function relaunch(){
electron.ipcRenderer.invoke(APP_RELAUNCH);
}
return function dockSetBadge(_x4) {
return _ref4.apply(this, arguments);
};
})();
async function getDefaultDoubleClickAction(){
return electron.ipcRenderer.invoke(APP_GET_DEFAULT_DOUBLE_CLICK_ACTION);
}
let dockBounce = (() => {
var _ref5 = _asyncToGenerator(function* (type) {
return electron.ipcRenderer.invoke(APP_DOCK_BOUNCE, type);
});
return function dockBounce(_x5) {
return _ref5.apply(this, arguments);
};
})();
let dockCancelBounce = (() => {
var _ref6 = _asyncToGenerator(function* (id) {
electron.ipcRenderer.invoke(APP_DOCK_CANCEL_BOUNCE, id);
});
return function dockCancelBounce(_x6) {
return _ref6.apply(this, arguments);
};
})();
let relaunch = (() => {
var _ref7 = _asyncToGenerator(function* () {
electron.ipcRenderer.invoke(APP_RELAUNCH);
});
return function relaunch() {
return _ref7.apply(this, arguments);
};
})();
let getDefaultDoubleClickAction = (() => {
var _ref8 = _asyncToGenerator(function* () {
return electron.ipcRenderer.invoke(APP_GET_DEFAULT_DOUBLE_CLICK_ACTION);
});
return function getDefaultDoubleClickAction() {
return _ref8.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const { UpdaterEvents } = require('../../Constants');
const allowedAppPaths = new Set(['home', 'appData', 'desktop', 'documents', 'downloads']);
const {
@ -56,9 +101,15 @@ electron.ipcRenderer.invoke(APP_GET_MODULE_VERSIONS).then(versions => {
moduleVersions = versions;
});
electron.ipcRenderer.on('DISCORD_MODULE_INSTALLED', async function(){
moduleVersions = await electron.ipcRenderer.invoke(APP_GET_MODULE_VERSIONS);
});
electron.ipcRenderer.on('DISCORD_MODULE_INSTALLED', (() => {
var _ref = _asyncToGenerator(function* (_) {
moduleVersions = yield electron.ipcRenderer.invoke(APP_GET_MODULE_VERSIONS);
});
return function (_x) {
return _ref.apply(this, arguments);
};
})());
function getReleaseChannel() {
return releaseChannel;

41
modules/discord_desktop_core/core/app/discord_native/renderer/clipboard.js Normal file
View File

@ -0,0 +1,41 @@
'use strict';
const electron = require('electron');
const invariant = require('invariant');
const { CLIPBOARD_COPY, CLIPBOARD_CUT, CLIPBOARD_PASTE } = require('../common/constants').IPCEvents;
function copy(text) {
if (text) {
electron.clipboard.writeText(text);
} else {
electron.ipcRenderer.invoke(CLIPBOARD_COPY);
}
}
function copyImage(imageArrayBuffer, imageSrc) {
invariant(imageArrayBuffer != null, 'Image data is empty');
const nativeImg = electron.nativeImage.createFromBuffer(imageArrayBuffer);
electron.clipboard.write({ html: `<img src="${imageSrc}">`, image: nativeImg });
}
function cut() {
electron.ipcRenderer.invoke(CLIPBOARD_CUT);
}
function paste() {
electron.ipcRenderer.invoke(CLIPBOARD_PASTE);
}
function read() {
return electron.clipboard.readText();
}
module.exports = {
copy,
copyImage,
cut,
paste,
read
};

38
modules/discord_desktop_core/core/app/discord_native/renderer/crashReporter.js Normal file
View File

@ -0,0 +1,38 @@
'use strict';
let updateCrashReporter = (() => {
var _ref = _asyncToGenerator(function* (additional_metadata) {
const result = yield electron.ipcRenderer.invoke(CRASH_REPORTER_UPDATE_METADATA, additional_metadata);
// Calling crashReporter.start from a renderer process was deprecated in Electron 9.
if (getElectronMajorVersion() < 9) {
//electron.crashReporter.start(result.args);
}
metadata = result.metadata || {};
reconcileCrashReporterMetadata(electron.crashReporter, metadata);
});
return function updateCrashReporter(_x) {
return _ref.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const { getElectronMajorVersion, reconcileCrashReporterMetadata } = require('../common/utility');
const { CRASH_REPORTER_UPDATE_METADATA } = require('../common/constants').IPCEvents;
let metadata = {};
updateCrashReporter(metadata);
function getMetadata() {
return metadata;
}
module.exports = {
updateCrashReporter,
getMetadata
};

21
modules/discord_desktop_core/core/app/discord_native/renderer/desktopCapture.js Normal file
View File

@ -0,0 +1,21 @@
'use strict';
const electron = require('electron');
function getDesktopCaptureSources(options) {
return new Promise((resolve, reject) => {
electron.desktopCapturer.getSources(options).then(sources => {
return resolve(sources.map(source => {
return {
id: source.id,
name: source.name,
url: source.thumbnail.toDataURL()
};
}));
});
});
}
module.exports = {
getDesktopCaptureSources
};

20
modules/discord_desktop_core/core/app/discord_native/renderer/features.js Normal file
View File

@ -0,0 +1,20 @@
'use strict';
const electron = require('electron');
const { FEATURES_GET_BROWSER_FEATURES } = require('../common/constants').IPCEvents;
let supportedFeatures = new Set(electron.ipcRenderer.sendSync(FEATURES_GET_BROWSER_FEATURES));
function supports(feature) {
return supportedFeatures.has(feature);
}
function declareSupported(feature) {
supportedFeatures.add(feature);
}
module.exports = {
supports,
declareSupported
};

201
modules/discord_desktop_core/core/app/discord_native/renderer/fileManager.js Normal file
View File

@ -0,0 +1,201 @@
'use strict';
let saveWithDialog = (() => {
var _ref = _asyncToGenerator(function* (fileContents, fileName, filePath) {
if (INVALID_FILENAME_CHAR_REGEX.test(fileName)) {
throw new Error(`fileName has invalid characters`);
}
const defaultPath = filePath != null ? path.join(os.homedir(), filePath, fileName) : path.join(os.homedir(), fileName);
const writeFileToDisk = function (selectedFileName) {
selectedFileName && fs.writeFileSync(selectedFileName, fileContents);
};
const results = yield electron.ipcRenderer.invoke(FILE_MANAGER_SHOW_SAVE_DIALOG, { defaultPath });
if (results && results.filePath) {
fs.writeFileSync(results.filePath, fileContents);
}
});
return function saveWithDialog(_x, _x2, _x3) {
return _ref.apply(this, arguments);
};
})();
let showOpenDialog = (() => {
var _ref2 = _asyncToGenerator(function* (dialogOptions) {
const results = yield electron.ipcRenderer.invoke(FILE_MANAGER_SHOW_OPEN_DIALOG, dialogOptions);
return results.filePaths;
});
return function showOpenDialog(_x4) {
return _ref2.apply(this, arguments);
};
})();
let orderedFiles = (() => {
var _ref3 = _asyncToGenerator(function* (folder) {
try {
const filenames = yield readdir(folder);
const times = yield getTimes(filenames.map(function (filename) {
return path.join(folder, filename);
}));
return times.filter(function (result) {
return result.status === 'fulfilled';
}).map(function (result) {
return result.value;
}).sort(function (a, b) {
return b.mtime.getTime() - a.mtime.getTime();
}).map(function (a) {
return a.filename;
});
} catch (err) {
return [];
}
});
return function orderedFiles(_x5) {
return _ref3.apply(this, arguments);
};
})();
let readLogFiles = (() => {
var _ref4 = _asyncToGenerator(function* (maxSize, makeFile) {
const modulePath = yield getModulePath();
const webrtcLog0 = path.join(modulePath, 'discord_voice', 'discord-webrtc_0');
const webrtcLog1 = path.join(modulePath, 'discord_voice', 'discord-webrtc_1');
const webrtcLog2 = path.join(modulePath, 'discord_voice', 'discord-last-webrtc_0');
const webrtcLog3 = path.join(modulePath, 'discord_voice', 'discord-last-webrtc_1');
const hookLog = path.join(modulePath, 'discord_hook', 'hook.log');
const audioState = path.join(modulePath, 'discord_voice', 'audio_state.json');
const filesToUpload = [webrtcLog0, webrtcLog1, webrtcLog2, webrtcLog3, hookLog, audioState];
const crashFolder = process.platform === 'win32' ? path.join(os.tmpdir(), 'Discord Crashes', 'reports') : path.join(os.tmpdir(), 'Discord Crashes', 'completed');
const crashFiles = yield orderedFiles(crashFolder);
if (crashFiles.length > 0) {
filesToUpload.push(crashFiles[0]);
}
const files = yield readFiles(filesToUpload, maxSize, function (data, filename) {
return makeFile(data, filename, 'application/octet-stream');
});
return files.filter(function (result) {
return result.status === 'fulfilled';
}).map(function (result) {
return result.value;
});
});
return function readLogFiles(_x6, _x7) {
return _ref4.apply(this, arguments);
};
})();
let showItemInFolder = (() => {
var _ref5 = _asyncToGenerator(function* (path) {
electron.ipcRenderer.invoke(FILE_MANAGER_SHOW_ITEM_IN_FOLDER, path);
});
return function showItemInFolder(_x8) {
return _ref5.apply(this, arguments);
};
})();
let openFiles = (() => {
var _ref6 = _asyncToGenerator(function* (dialogOptions, maxSize, makeFile) {
const filenames = yield showOpenDialog(dialogOptions);
if (filenames == null) {
return;
}
const files = yield readFiles(filenames, maxSize, makeFile);
files.forEach(function (result) {
if (result.status === 'rejected') {
throw result.reason;
}
});
return files.map(function (result) {
return result.value;
});
});
return function openFiles(_x9, _x10, _x11) {
return _ref6.apply(this, arguments);
};
})();
let getModulePath = (() => {
var _ref7 = _asyncToGenerator(function* () {
return electron.ipcRenderer.invoke(FILE_MANAGER_GET_MODULE_PATH);
});
return function getModulePath() {
return _ref7.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const fs = require('fs');
const os = require('os');
const path = require('path');
const originalFs = require('original-fs');
const util = require('util');
const {
FILE_MANAGER_GET_MODULE_PATH,
FILE_MANAGER_SHOW_SAVE_DIALOG,
FILE_MANAGER_SHOW_OPEN_DIALOG,
FILE_MANAGER_SHOW_ITEM_IN_FOLDER
} = require('../common/constants').IPCEvents;
const INVALID_FILENAME_CHAR_REGEX = /[^a-zA-Z0-9-_.]/g;
const readdir = util.promisify(originalFs.readdir);
function getTimes(filenames) {
return Promise.allSettled(filenames.map(filename => new Promise((resolve, reject) => {
originalFs.stat(filename, (err, stats) => {
if (err) {
return reject(err);
}
if (!stats.isFile()) {
return reject(new Error('Not a file'));
}
return resolve({ filename, mtime: stats.mtime });
});
})));
}
function readFiles(filenames, maxSize, makeFile) {
return Promise.allSettled(filenames.map(filename => new Promise((resolve, reject) => {
originalFs.stat(filename, (err, stats) => {
if (err) return reject(err);
if (stats.size > maxSize) {
const err = new Error('upload too large');
// used to help determine why openFiles failed
err.code = 'ETOOLARGE';
return reject(err);
}
originalFs.readFile(filename, (err, data) => {
if (err) return reject(err);
return resolve(makeFile(data.buffer, path.basename(filename)));
});
});
})));
}
module.exports = {
readLogFiles,
saveWithDialog,
openFiles,
showOpenDialog,
showItemInFolder,
getModulePath,
extname: path.extname,
basename: path.basename,
dirname: path.dirname,
join: path.join
};

28
modules/discord_desktop_core/core/app/discord_native/renderer/gpuSettings.js Normal file
View File

@ -0,0 +1,28 @@
'use strict';
let setEnableHardwareAcceleration = (() => {
var _ref = _asyncToGenerator(function* (enable) {
electron.ipcRenderer.invoke(GPU_SETTINGS_SET_ENABLE_HWACCEL, enable);
});
return function setEnableHardwareAcceleration(_x) {
return _ref.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const { GPU_SETTINGS_SET_ENABLE_HWACCEL, GPU_SETTINGS_GET_ENABLE_HWACCEL_SYNC } = require('../common/constants').IPCEvents;
const hardwareAccelerationEnabled = electron.ipcRenderer.sendSync(GPU_SETTINGS_GET_ENABLE_HWACCEL_SYNC);
function getEnableHardwareAcceleration() {
return hardwareAccelerationEnabled;
}
module.exports = {
getEnableHardwareAcceleration,
setEnableHardwareAcceleration
};

79
modules/discord_desktop_core/core/app/discord_native/renderer/http.js Normal file
View File

@ -0,0 +1,79 @@
'use strict';
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const http = require('http');
const https = require('https');
function makeChunkedRequest(route, chunks, options, callback) {
/**
* Given an array of chunks, make a slow request, only writing chunks
* after a specified amount of time
*
* route: string
* options: object
* method: the method of the request
* contentType: the content type of the request
* chunkInterval: how long to wait to upload a chunk after the last chunk was flushed
* token: the token to make an authorized request from
* chunks: chunked body of the request to upload
*/
const { method, chunkInterval, token, contentType } = options;
let httpModule = http;
if (route.startsWith('https')) {
httpModule = https;
}
const requestPromise = new Promise((() => {
var _ref = _asyncToGenerator(function* (resolve, reject) {
let writeTimeout;
const req = httpModule.request(route, {
method,
headers: {
authorization: token,
'Content-Type': contentType,
'Content-Length': Buffer.byteLength(chunks.join(''))
}
}, function (res) {
let responseData = '';
res.setEncoding('utf8');
res.on('data', function (chunk) {
responseData += chunk;
});
res.on('end', function () {
resolve({ status: res.statusCode, body: responseData });
});
});
req.on('error', function (e) {
if (writeTimeout != null) {
clearTimeout(writeTimeout);
}
reject(e);
});
for (let i = 0; i < chunks.length; i++) {
yield new Promise(function (resolve) {
req.write(chunks[i], function () {
writeTimeout = setTimeout(resolve, chunkInterval);
});
});
}
req.end();
});
return function (_x, _x2) {
return _ref.apply(this, arguments);
};
})());
requestPromise.then(body => callback(null, body)).catch(callback);
}
module.exports = {
makeChunkedRequest
};

19
modules/discord_desktop_core/core/app/discord_native/renderer/ipc.js Normal file
View File

@ -0,0 +1,19 @@
'use strict';
const electron = require('electron');
const { getDiscordIPCEvent } = require('../common/constants');
const ipcRenderer = electron.ipcRenderer;
function send(ev, ...args) {
ipcRenderer.send(getDiscordIPCEvent(ev), ...args);
}
function on(ev, callback) {
ipcRenderer.on(getDiscordIPCEvent(ev), callback);
}
module.exports = {
send,
on
};

69
modules/discord_desktop_core/core/app/discord_native/renderer/nativeModules.js Normal file
View File

@ -0,0 +1,69 @@
'use strict';
let ensureModule = (() => {
var _ref = _asyncToGenerator(function* (name) {
let modulePromise = modulePromises[name];
if (modulePromise == null) {
modulePromise = electron.ipcRenderer.invoke(NATIVE_MODULES_INSTALL, name);
}
return modulePromise;
});
return function ensureModule(_x) {
return _ref.apply(this, arguments);
};
})();
// TODO: remove this sandboxing when we turn contextIsolation on
// sandbox this function in a new context, else it's susceptible to prototype attacks
// - RegExp.prototype.test = () => true
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const vm = require('vm');
const { NATIVE_MODULES_GET_PATHS, NATIVE_MODULES_INSTALL } = require('../common/constants').IPCEvents;
const modulePromises = {};
function getSanitizedModulePaths() {
let sanitizedModulePaths = [];
const { mainAppDirname, browserModulePaths } = electron.ipcRenderer.sendSync(NATIVE_MODULES_GET_PATHS);
browserModulePaths.forEach(modulePath => {
if (!modulePath.includes('electron.asar')) {
sanitizedModulePaths.push(modulePath);
}
});
const rendererModulePaths = require('module')._nodeModulePaths(mainAppDirname);
sanitizedModulePaths = sanitizedModulePaths.concat(rendererModulePaths.slice(0, 2));
return sanitizedModulePaths;
}
const context = vm.createContext(Object.create(null));
const _requireModule = vm.runInContext(`
function requireModule(localRequire, name) {
if (!/^discord_[a-z0-9_-]+$/.test(name) && name !== 'erlpack') {
throw new Error('"' + String(name) + '" is not a whitelisted native module');
}
return localRequire(name);
}
requireModule
`, context);
function requireModule(name) {
return _requireModule((id) => {
return require("../../../../../"+id)
}, name);
}
module.paths = getSanitizedModulePaths();
module.exports = {
ensureModule,
requireModule
};

14
modules/discord_desktop_core/core/app/discord_native/renderer/os.js Normal file
View File

@ -0,0 +1,14 @@
'use strict';
const os = require('os');
const process = require('process');
let arch = os.arch();
if (process.platform === 'win32' && process.env['PROCESSOR_ARCHITEW6432'] != null) {
arch = 'x64';
}
module.exports = {
release: os.release(),
arch
};

61
modules/discord_desktop_core/core/app/discord_native/renderer/powerMonitor.js Normal file
View File

@ -0,0 +1,61 @@
'use strict';
let getSystemIdleTimeMs = (() => {
var _ref = _asyncToGenerator(function* () {
return electron.ipcRenderer.invoke(POWER_MONITOR_GET_SYSTEM_IDLE_TIME);
});
return function getSystemIdleTimeMs() {
return _ref.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const EventEmitter = require('events');
const {
POWER_MONITOR_RESUME,
POWER_MONITOR_SUSPEND,
POWER_MONITOR_LOCK_SCREEN,
POWER_MONITOR_UNLOCK_SCREEN,
POWER_MONITOR_GET_SYSTEM_IDLE_TIME
} = require('../common/constants').IPCEvents;
const events = new EventEmitter();
electron.ipcRenderer.on(POWER_MONITOR_RESUME, () => {
events.emit('resume');
});
electron.ipcRenderer.on(POWER_MONITOR_SUSPEND, () => {
events.emit('suspend');
});
electron.ipcRenderer.on(POWER_MONITOR_LOCK_SCREEN, () => {
events.emit('lock-screen');
});
electron.ipcRenderer.on(POWER_MONITOR_UNLOCK_SCREEN, () => {
events.emit('unlock-screen');
});
function on() {
events.on.apply(events, arguments);
}
function removeListener() {
events.removeListener.apply(events, arguments);
}
function removeAllListeners() {
events.removeAllListeners.apply(events, arguments);
}
module.exports = {
on,
removeListener,
removeAllListeners,
getSystemIdleTimeMs
};

47
modules/discord_desktop_core/core/app/discord_native/renderer/powerSaveBlocker.js Normal file
View File

@ -0,0 +1,47 @@
'use strict';
let blockDisplaySleep = (() => {
var _ref = _asyncToGenerator(function* () {
return electron.ipcRenderer.invoke(POWER_SAVE_BLOCKER_BLOCK_DISPLAY_SLEEP);
});
return function blockDisplaySleep() {
return _ref.apply(this, arguments);
};
})();
let unblockDisplaySleep = (() => {
var _ref2 = _asyncToGenerator(function* (id) {
return electron.ipcRenderer.invoke(POWER_SAVE_BLOCKER_UNBLOCK_DISPLAY_SLEEP, id);
});
return function unblockDisplaySleep(_x) {
return _ref2.apply(this, arguments);
};
})();
let cleanupDisplaySleep = (() => {
var _ref3 = _asyncToGenerator(function* () {
return electron.ipcRenderer.invoke(POWER_SAVE_BLOCKER_CLEANUP_DISPLAY_SLEEP);
});
return function cleanupDisplaySleep() {
return _ref3.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const {
POWER_SAVE_BLOCKER_BLOCK_DISPLAY_SLEEP,
POWER_SAVE_BLOCKER_UNBLOCK_DISPLAY_SLEEP,
POWER_SAVE_BLOCKER_CLEANUP_DISPLAY_SLEEP
} = require('../common/constants').IPCEvents;
module.exports = {
blockDisplaySleep,
unblockDisplaySleep,
cleanupDisplaySleep
};

17
modules/discord_desktop_core/core/app/discord_native/renderer/process.js Normal file
View File

@ -0,0 +1,17 @@
'use strict';
const electron = require('electron');
const process = require('process');
const env = process.env;
module.exports = {
platform: process.platform,
arch: process.arch,
env: {
LOCALAPPDATA: env['LOCALAPPDATA'],
'PROGRAMFILES(X86)': env['PROGRAMFILES(X86)'],
PROGRAMFILES: env['PROGRAMFILES'],
PROGRAMW6432: env['PROGRAMW6432'],
PROGRAMDATA: env['PROGRAMDATA']
}
};

103
modules/discord_desktop_core/core/app/discord_native/renderer/processUtils.js Normal file
View File

@ -0,0 +1,103 @@
'use strict';
let flushDNSCache = (() => {
var _ref = _asyncToGenerator(function* () {
electron.ipcRenderer.invoke(PROCESS_UTILS_FLUSH_DNS_CACHE);
});
return function flushDNSCache() {
return _ref.apply(this, arguments);
};
})();
let flushCookies = (() => {
var _ref2 = _asyncToGenerator(function* (callback) {
try {
yield electron.ipcRenderer.invoke(PROCESS_UTILS_FLUSH_COOKIES);
callback();
} catch (err) {
callback(err);
}
});
return function flushCookies(_x) {
return _ref2.apply(this, arguments);
};
})();
let flushStorageData = (() => {
var _ref3 = _asyncToGenerator(function* (callback) {
try {
yield electron.ipcRenderer.invoke(PROCESS_UTILS_FLUSH_STORAGE_DATA);
callback();
} catch (err) {
callback(err);
}
});
return function flushStorageData(_x2) {
return _ref3.apply(this, arguments);
};
})();
let purgeMemory = (() => {
var _ref4 = _asyncToGenerator(function* () {
electron.webFrame.clearCache();
});
return function purgeMemory() {
return _ref4.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const process = require('process');
const {
PROCESS_UTILS_GET_CPU_USAGE,
PROCESS_UTILS_GET_MEMORY_INFO,
PROCESS_UTILS_FLUSH_DNS_CACHE,
PROCESS_UTILS_FLUSH_COOKIES,
PROCESS_UTILS_FLUSH_STORAGE_DATA,
PROCESS_UTILS_GET_MAIN_ARGV_SYNC
} = require('../common/constants').IPCEvents;
const CPU_USAGE_GATHER_INTERVAL = 1000;
const MEMORY_USAGE_GATHER_INTERVAL = 5000;
const mainArgv = electron.ipcRenderer.sendSync(PROCESS_UTILS_GET_MAIN_ARGV_SYNC);
let totalProcessorUsagePercent = 0;
let totalMemoryUsageKB = 0;
setInterval(() => {
electron.ipcRenderer.invoke(PROCESS_UTILS_GET_CPU_USAGE).then(usage => totalProcessorUsagePercent = usage);
}, CPU_USAGE_GATHER_INTERVAL);
setInterval(() => {
Promise.all([process.getProcessMemoryInfo(), electron.ipcRenderer.invoke(PROCESS_UTILS_GET_MEMORY_INFO)].map(x => x.catch(() => 0))).then(usages => {
totalMemoryUsageKB = usages.reduce((total, usage) => total + usage.private, 0);
});
}, MEMORY_USAGE_GATHER_INTERVAL);
function getCurrentCPUUsagePercent() {
return totalProcessorUsagePercent;
}
function getCurrentMemoryUsageKB() {
return totalMemoryUsageKB;
}
function getMainArgvSync() {
return mainArgv;
}
module.exports = {
flushDNSCache,
flushCookies,
flushStorageData,
purgeMemory,
getCurrentCPUUsagePercent,
getCurrentMemoryUsageKB,
getMainArgvSync
};

37
modules/discord_desktop_core/core/app/discord_native/renderer/settings.js Normal file
View File

@ -0,0 +1,37 @@
'use strict';
let get = (() => {
var _ref = _asyncToGenerator(function* (name, defaultValue) {
return electron.ipcRenderer.invoke(SETTINGS_GET, name, defaultValue);
});
return function get(_x, _x2) {
return _ref.apply(this, arguments);
};
})();
let set = (() => {
var _ref2 = _asyncToGenerator(function* (name, value) {
return electron.ipcRenderer.invoke(SETTINGS_SET, name, value);
});
return function set(_x3, _x4) {
return _ref2.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const { SETTINGS_GET, SETTINGS_SET, SETTINGS_GET_SYNC } = require('../common/constants').IPCEvents;
function getSync(name, defaultValue) {
return electron.ipcRenderer.sendSync(SETTINGS_GET_SYNC, name, defaultValue);
}
module.exports = {
get,
set,
getSync
};

121
modules/discord_desktop_core/core/app/discord_native/renderer/spellCheck.js Normal file
View File

@ -0,0 +1,121 @@
'use strict';
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const EventEmitter = require('events');
const { getElectronMajorVersion } = require('../common/utility');
const {
SPELLCHECK_RESULT,
SPELLCHECK_REPLACE_MISSPELLING,
SPELLCHECK_GET_AVAILABLE_DICTIONARIES,
SPELLCHECK_SET_LOCALE,
SPELLCHECK_SET_LEARNED_WORDS
} = require('../common/constants').IPCEvents;
if (getElectronMajorVersion() < 8) {
let setSpellCheckProvider = (() => {
var _ref = _asyncToGenerator(function* (locale, autoCorrectWord, provider) {
const asyncProvider = {
spellCheck: function (words, callback) {
return callback(words.filter(function (word) {
return !provider.spellCheck(word);
}));
}
};
electron.webFrame.setSpellCheckProvider(locale, asyncProvider);
});
return function setSpellCheckProvider(_x, _x2, _x3) {
return _ref.apply(this, arguments);
};
})();
let replaceMisspelling = (() => {
var _ref2 = _asyncToGenerator(function* (word) {
electron.ipcRenderer.invoke(SPELLCHECK_REPLACE_MISSPELLING, word);
});
return function replaceMisspelling(_x4) {
return _ref2.apply(this, arguments);
};
})();
module.exports = {
setSpellCheckProvider,
replaceMisspelling
};
} else {
let getAvailableDictionaries = (() => {
var _ref3 = _asyncToGenerator(function* () {
return electron.ipcRenderer.invoke(SPELLCHECK_GET_AVAILABLE_DICTIONARIES);
});
return function getAvailableDictionaries() {
return _ref3.apply(this, arguments);
};
})();
let setLocale = (() => {
var _ref4 = _asyncToGenerator(function* (locale) {
let succeeded = true;
try {
yield electron.ipcRenderer.invoke(SPELLCHECK_SET_LOCALE, locale);
} catch (_) {
succeeded = false;
}
return succeeded;
});
return function setLocale(_x5) {
return _ref4.apply(this, arguments);
};
})();
let setLearnedWords = (() => {
var _ref5 = _asyncToGenerator(function* (learnedWords) {
return electron.ipcRenderer.invoke(SPELLCHECK_SET_LEARNED_WORDS, learnedWords);
});
return function setLearnedWords(_x6) {
return _ref5.apply(this, arguments);
};
})();
let replaceMisspelling = (() => {
var _ref6 = _asyncToGenerator(function* (correction) {
return electron.ipcRenderer.invoke(SPELLCHECK_REPLACE_MISSPELLING, correction);
});
return function replaceMisspelling(_x7) {
return _ref6.apply(this, arguments);
};
})();
const events = new EventEmitter();
electron.ipcRenderer.on(SPELLCHECK_RESULT, handleSpellcheckData);
function handleSpellcheckData(_, misspelledWord, dictionarySuggestions) {
events.emit('spellcheck-result', misspelledWord, dictionarySuggestions);
}
function on() {
events.on.apply(events, arguments);
}
function removeListener() {
events.removeListener.apply(events, arguments);
}
module.exports = {
on,
removeListener,
getAvailableDictionaries,
setLocale,
setLearnedWords,
replaceMisspelling
};
}

208
modules/discord_desktop_core/core/app/discord_native/renderer/window.js Normal file
View File

@ -0,0 +1,208 @@
'use strict';
let flashFrame = (() => {
var _ref3 = _asyncToGenerator(function* (flag) {
electron.ipcRenderer.invoke(WINDOW_FLASH_FRAME, flag);
});
return function flashFrame(_x3) {
return _ref3.apply(this, arguments);
};
})();
let minimize = (() => {
var _ref4 = _asyncToGenerator(function* (key) {
electron.ipcRenderer.invoke(WINDOW_MINIMIZE, key);
});
return function minimize(_x4) {
return _ref4.apply(this, arguments);
};
})();
let restore = (() => {
var _ref5 = _asyncToGenerator(function* (key) {
electron.ipcRenderer.invoke(WINDOW_RESTORE, key);
});
return function restore(_x5) {
return _ref5.apply(this, arguments);
};
})();
let maximize = (() => {
var _ref6 = _asyncToGenerator(function* (key) {
electron.ipcRenderer.invoke(WINDOW_MAXIMIZE, key);
});
return function maximize(_x6) {
return _ref6.apply(this, arguments);
};
})();
let focus = (() => {
var _ref7 = _asyncToGenerator(function* (_hack, key) {
electron.ipcRenderer.invoke(WINDOW_FOCUS, key);
});
return function focus(_x7, _x8) {
return _ref7.apply(this, arguments);
};
})();
let setAlwaysOnTop = (() => {
var _ref8 = _asyncToGenerator(function* (key, enabled) {
return electron.ipcRenderer.invoke(WINDOW_SET_ALWAYS_ON_TOP, key, enabled);
});
return function setAlwaysOnTop(_x9, _x10) {
return _ref8.apply(this, arguments);
};
})();
let isAlwaysOnTop = (() => {
var _ref9 = _asyncToGenerator(function* (key) {
return electron.ipcRenderer.invoke(WINDOW_IS_ALWAYS_ON_TOP, key);
});
return function isAlwaysOnTop(_x11) {
return _ref9.apply(this, arguments);
};
})();
let blur = (() => {
var _ref10 = _asyncToGenerator(function* (key) {
electron.ipcRenderer.invoke(WINDOW_BLUR, key);
});
return function blur(_x12) {
return _ref10.apply(this, arguments);
};
})();
let setProgressBar = (() => {
var _ref11 = _asyncToGenerator(function* (progress, key) {
electron.ipcRenderer.invoke(WINDOW_SET_PROGRESS_BAR, key, progress);
});
return function setProgressBar(_x13, _x14) {
return _ref11.apply(this, arguments);
};
})();
let fullscreen = (() => {
var _ref12 = _asyncToGenerator(function* (key) {
electron.ipcRenderer.invoke(WINDOW_TOGGLE_FULLSCREEN, key);
});
return function fullscreen(_x15) {
return _ref12.apply(this, arguments);
};
})();
let close = (() => {
var _ref13 = _asyncToGenerator(function* (key) {
electron.ipcRenderer.invoke(WINDOW_CLOSE, key);
});
return function close(_x16) {
return _ref13.apply(this, arguments);
};
})();
let setZoomFactor = (() => {
var _ref14 = _asyncToGenerator(function* (factor) {
if (!electron.webFrame.setZoomFactor) return;
electron.webFrame.setZoomFactor(factor / 100);
});
return function setZoomFactor(_x17) {
return _ref14.apply(this, arguments);
};
})();
let setBackgroundThrottling = (() => {
var _ref15 = _asyncToGenerator(function* (enabled) {
electron.ipcRenderer.invoke(WINDOW_SET_BACKGROUND_THROTTLING, enabled);
});
return function setBackgroundThrottling(_x18) {
return _ref15.apply(this, arguments);
};
})();
let setDevtoolsCallbacks = (() => {
var _ref16 = _asyncToGenerator(function* (onOpened, onClosed) {
devtoolsOpenedCallback = onOpened;
devtoolsClosedCallback = onClosed;
});
return function setDevtoolsCallbacks(_x19, _x20) {
return _ref16.apply(this, arguments);
};
})();
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const electron = require('electron');
const {
WINDOW_BLUR,
WINDOW_CLOSE,
WINDOW_FOCUS,
WINDOW_MAXIMIZE,
WINDOW_MINIMIZE,
WINDOW_RESTORE,
WINDOW_FLASH_FRAME,
WINDOW_TOGGLE_FULLSCREEN,
WINDOW_SET_BACKGROUND_THROTTLING,
WINDOW_SET_PROGRESS_BAR,
WINDOW_IS_ALWAYS_ON_TOP,
WINDOW_SET_ALWAYS_ON_TOP,
WINDOW_DEVTOOLS_OPENED,
WINDOW_DEVTOOLS_CLOSED
} = require('../common/constants').IPCEvents;
let devtoolsOpenedCallback = () => {};
let devtoolsClosedCallback = () => {};
electron.ipcRenderer.on(WINDOW_DEVTOOLS_OPENED, (() => {
var _ref = _asyncToGenerator(function* (_) {
if (devtoolsOpenedCallback != null) {
devtoolsOpenedCallback();
}
});
return function (_x) {
return _ref.apply(this, arguments);
};
})());
electron.ipcRenderer.on(WINDOW_DEVTOOLS_CLOSED, (() => {
var _ref2 = _asyncToGenerator(function* (_) {
if (devtoolsOpenedCallback != null) {
devtoolsOpenedCallback();
}
});
return function (_x2) {
return _ref2.apply(this, arguments);
};
})());
module.exports = {
flashFrame,
minimize,
restore,
maximize,
focus,
blur,
fullscreen,
close,
setAlwaysOnTop,
isAlwaysOnTop,
setZoomFactor,
setBackgroundThrottling,
setProgressBar,
setDevtoolsCallbacks
};

33
modules/discord_desktop_core/core/app/index.js
View File

@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
exports.startup = startup;
exports.handleSingleInstance = handleSingleInstance;
exports.setMainWindowVisible = setMainWindowVisible;
const { Menu } = require('electron');
const { Menu, BrowserWindow } = require('electron');
const yauzl = require("yauzl")
const fetch = require("node-fetch").default
@ -21,7 +21,7 @@ function startup(bootstrapModules) {
require('./splashScreen');
const moduleUpdater = require('./moduleUpdater');
require('./autoStart');
require('./buildInfo');
const buildInfo = require('./buildInfo');
const appSettings = require('./appSettings');
const Constants = require('./Constants');
@ -37,19 +37,26 @@ function startup(bootstrapModules) {
rootCertificates.init();
require('./discord_native/browser/accessibility');
require('./discord_native/browser/app');
const app = require('./discord_native/browser/app');
app.injectBuildInfo(buildInfo);
app.injectModuleUpdater(moduleUpdater);
require('./discord_native/browser/clipboard');
const crashReporter = require('./discord_native/browser/crashReporter');
require('./discord_native/browser/features');
crashReporter.injectBuildInfo(buildInfo);
const features = require('./discord_native/browser/features');
features.injectFeaturesBackend(appFeatures.getFeatures());
require('./discord_native/browser/fileManager');
require('./discord_native/browser/gpuSettings');
require('./discord_native/browser/nativeModules');
const gpuSettings = require('./discord_native/browser/gpuSettings');
gpuSettings.injectGpuSettingsBackend(GPUSettings);
const nativeModules = require('./discord_native/browser/nativeModules');
nativeModules.injectModuleUpdater(moduleUpdater);
require('./discord_native/browser/powerMonitor');
require('./discord_native/browser/powerSaveBlocker');
require('./discord_native/browser/processUtils');
require('./discord_native/browser/settings');
const settings = require('./discord_native/browser/settings');
settings.injectSettingsBackend(appSettings.getSettings());
require('./discord_native/browser/spellCheck');
require('./discord_native/browser/window');
const windowNative = require('./discord_native/browser/window');
// expose globals that will be imported by the webapp
// global.releaseChannel is set in bootstrap
@ -73,6 +80,11 @@ function startup(bootstrapModules) {
})
bootstrapModules.splashScreen.events.on("APP_SHOULD_LAUNCH", () => {
mainScreen.init(false)
const { getWindow: getPopoutWindowByKey } = require('./popoutWindows');
windowNative.injectGetWindow(key => {
return getPopoutWindowByKey(key) || BrowserWindow.fromId(mainScreen.getMainWindowId());
});
})
mainScreen.events.on("ready", () => {
@ -88,6 +100,11 @@ function startup(bootstrapModules) {
if(Date.now() - global.appSettings.get("LAST_UPDATE_CHECK_TIMESTAMP", 0) < 6.48e+8){
console.log("Starting with version "+version+" because it haven't been 1 week since the last check.")
mainScreen.init(false)
const { getWindow: getPopoutWindowByKey } = require('./popoutWindows');
windowNative.injectGetWindow(key => {
return getPopoutWindowByKey(key) || BrowserWindow.fromId(mainScreen.getMainWindowId());
});
}else{
initByUpdate = true
console.log("Checking if version "+version+" is outdated...")

42
modules/discord_desktop_core/core/app/mainScreenPreload.js
View File

@ -20,27 +20,31 @@ ipcRenderer.on(TRACK_ANALYTICS_EVENT, e => {
const DiscordNative = {
isRenderer: process.type === 'renderer',
nativeModules: require('./discord_native/nativeModules'),
globals: require('./discord_native/globals'),
process: require('./discord_native/process'),
os: require('./discord_native/os'),
remoteApp: require('./discord_native/remoteApp'),
clipboard: require('./discord_native/clipboard'),
ipc: ipcRenderer,
gpuSettings: require('./discord_native/gpuSettings'),
window: require('./discord_native/window'),
remotePowerMonitor: require('./discord_native/remotePowerMonitor'),
spellCheck: require('./discord_native/spellCheck'),
crashReporter: require('./discord_native/crashReporter'),
desktopCapture: require('./discord_native/desktopCapture'),
fileManager: require('./discord_native/fileManager'),
processUtils: require('./discord_native/processUtils'),
powerSaveBlocker: require('./discord_native/powerSaveBlocker'),
http: require('./discord_native/http'),
accessibility: require('./discord_native/accessibility'),
app: require("./discord_native/renderer/app")
nativeModules: require('./discord_native/renderer/nativeModules'),
process: require('./discord_native/renderer/process'),
os: require('./discord_native/renderer/os'),
app: require('./discord_native/renderer/app'),
clipboard: require('./discord_native/renderer/clipboard'),
ipc: require('./discord_native/renderer/ipc'),
gpuSettings: require('./discord_native/renderer/gpuSettings'),
window: require('./discord_native/renderer/window'),
powerMonitor: require('./discord_native/renderer/powerMonitor'),
spellCheck: require('./discord_native/renderer/spellCheck'),
crashReporter: require('./discord_native/renderer/crashReporter'),
desktopCapture: require('./discord_native/renderer/desktopCapture'),
fileManager: require('./discord_native/renderer/fileManager'),
processUtils: require('./discord_native/renderer/processUtils'),
powerSaveBlocker: require('./discord_native/renderer/powerSaveBlocker'),
http: require('./discord_native/renderer/http'),
accessibility: require('./discord_native/renderer/accessibility'),
features: require('./discord_native/renderer/features'),
settings: require('./discord_native/renderer/settings')
};
// TODO: remove these once web no longer uses them
DiscordNative.remoteApp = DiscordNative.app;
DiscordNative.remotePowerMonitor = DiscordNative.powerMonitor;
const BetterDiscord = require("./BetterDiscord")
process.once('loaded', () => {

BIN
modules/discord_voice/discord_voice.node
View File

Binary file not shown.

44
modules/discord_voice/index.js
View File

@ -6,19 +6,18 @@ const yargs = require('yargs');
const isElectronRenderer =
typeof window !== 'undefined' && window != null && window.DiscordNative && window.DiscordNative.isRenderer;
const appSettings = isElectronRenderer ? require('electron').remote.getGlobal('appSettings') : global.appSettings;
const features = isElectronRenderer ? require('electron').remote.getGlobal('features') : global.features;
const mainArgv = isElectronRenderer ? require('electron').remote.process.argv : [];
const releaseChannel = isElectronRenderer ? require('electron').remote.getGlobal('releaseChannel') : '';
const dialog = isElectronRenderer ? require('electron').remote.dialog : null;
const useLegacyAudioDevice = appSettings ? appSettings.get('useLegacyAudioDevice') : false;
const appSettings = isElectronRenderer ? window.DiscordNative.settings : global.appSettings;
const features = isElectronRenderer ? window.DiscordNative.features : global.features;
const mainArgv = isElectronRenderer ? window.DiscordNative.processUtils.getMainArgvSync() : [];
const releaseChannel = isElectronRenderer ? window.DiscordNative.app.getReleaseChannel() : '';
const useLegacyAudioDevice = appSettings ? appSettings.getSync('useLegacyAudioDevice') : false;
const audioSubsystemSelected = appSettings
? appSettings.get('audioSubsystem') === 'legacy'
? appSettings.getSync('audioSubsystem') === 'legacy'
? 'legacy'
: 'standard'
: 'standard';
const audioSubsystem = useLegacyAudioDevice || audioSubsystemSelected;
const debugLogging = appSettings ? appSettings.get('debugLogging') : false;
const debugLogging = appSettings ? appSettings.getSync('debugLogging') : false;
const argv = yargs(mainArgv.slice(1))
.describe('log-level', 'Logging level.')
@ -62,6 +61,7 @@ features.declareSupported('loopback');
features.declareSupported('experiment_config');
features.declareSupported('remote_locus_network_control');
features.declareSupported('connection_replay');
features.declareSupported('simulcast');
if (process.platform === 'win32') {
features.declareSupported('voice_legacy_subsystem');
@ -88,19 +88,13 @@ if (isElectronRenderer) {
VoiceEngine.setImageDataAllocator((width, height) => new window.ImageData(width, height));
}
if (dialog != null) {
VoiceEngine.createReplayConnection = function (audioEngineId, callback) {
const paths = dialog.showOpenDialogSync(null, {
filters: [{name: 'All Files', extensions: ['*']}],
});
VoiceEngine.createReplayConnection = function (audioEngineId, callback, replayLog) {
if (replayLog == null) {
return null;
}
if (paths == null || paths.length === 0) {
return null;
}
return new VoiceReplayConnection(paths[0], audioEngineId, callback);
};
}
return new VoiceReplayConnection(replayLog, audioEngineId, callback);
};
VoiceEngine.setAudioSubsystem = function (subsystem) {
if (appSettings == null) {
@ -117,9 +111,10 @@ VoiceEngine.setAudioSubsystem = function (subsystem) {
appSettings.set('audioSubsystem', subsystem);
appSettings.set('useLegacyAudioDevice', false);
appSettings.save();
reloadElectronApp();
if (isElectronRenderer) {
window.DiscordNative.app.relaunch();
}
};
VoiceEngine.setDebugLogging = function (enable) {
@ -134,8 +129,9 @@ VoiceEngine.setDebugLogging = function (enable) {
appSettings.set('debugLogging', enable);
appSettings.save();
reloadElectronApp();
if (isElectronRenderer) {
window.DiscordNative.app.relaunch();
}
};
VoiceEngine.getDebugLogging = function () {

47
package-lock.json generated
View File

@ -317,6 +317,17 @@
"resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
"integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac="
},
"cross-spawn": {
"version": "7.0.3",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
"integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
"dev": true,
"requires": {
"path-key": "^3.1.0",
"shebang-command": "^2.0.0",
"which": "^2.0.1"
}
},
"custom-electron-titlebar": {
"version": "3.2.2-hotfix62",
"resolved": "https://registry.npmjs.org/custom-electron-titlebar/-/custom-electron-titlebar-3.2.2-hotfix62.tgz",
@ -699,6 +710,12 @@
"integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
"dev": true
},
"isexe": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
"integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
"dev": true
},
"isstream": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz",
@ -904,6 +921,12 @@
"resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
"integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
},
"path-key": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
"integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
"dev": true
},
"pend": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
@ -1138,6 +1161,21 @@
"type-fest": "^0.8.0"
}
},
"shebang-command": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
"integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
"dev": true,
"requires": {
"shebang-regex": "^3.0.0"
}
},
"shebang-regex": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
"integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
"dev": true
},
"source-map": {
"version": "0.6.1",
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
@ -1326,6 +1364,15 @@
"extsprintf": "^1.2.0"
}
},
"which": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
"integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
"dev": true,
"requires": {
"isexe": "^2.0.0"
}
},
"winreg": {
"version": "1.2.4",
"resolved": "https://registry.npmjs.org/winreg/-/winreg-1.2.4.tgz",

8
package.json
View File

@ -4,11 +4,12 @@
"description": "",
"main": "dist/index.js",
"scripts": {
"test": "tsc && electron .",
"compile": "node compile.js",
"test": "npm run compile && electron .",
"run": "electron .",
"build": "npm run build:minify && npm run build:electron",
"build:electron": "electron-packager ./distApp --ignore=\"(distApp|builds|\\.ts)\" --arch=ia32 --win32metadata.ProductName=\"Lightcord\" --win32metadata.CompanyName=\"Lightcord Inc.\" --protocol=discord --platform=\"win32,linux\" --out=builds --icon=app.ico --executable-name=\"Lightcord\" --asar.unpack=*.{node,dll} --overwrite",
"build:minify": "node compile.js",
"build:electron": "electron-packager ./distApp --ignore=\"(distApp|builds|\\.ts)\" --arch=ia32 --win32metadata.ProductName=\"Lightcord\" --win32metadata.CompanyName=\"Lightcord\" --protocol=discord --platform=\"win32,linux\" --out=builds --icon=app.ico --executable-name=\"Lightcord\" --asar.unpack=*.{node,dll} --overwrite",
"build:minify": "node build.js",
"devInstall": "npm i -g --arch=ia32 electron@8.3.0 && npm i -g typescript && npm i --save-dev @types/node@12.12.39 && npm i --save-dev --arch=ia32 electron@8.3.0 && node installSubModules.js && echo \"Everything is installed. You should be able to do `npm run test` to compile everything and launch.\""
},
"author": "",
@ -33,6 +34,7 @@
"@types/rimraf": "^3.0.0",
"@types/uuid": "^8.0.0",
"@types/yauzl": "^2.9.1",
"cross-spawn": "^7.0.3",
"electron": "8.3.0",
"react": "^16.13.1",
"react-dom": "^16.13.1",

2
src/Constants.ts
View File

@ -7,7 +7,7 @@ import appSettings from './appSettings';
const pak = require("../package.json")
import * as path from "path"
const settings = appSettings();
const settings = appSettings.getSettings();
function capitalizeFirstLetter(s) {
return s.charAt(0).toUpperCase() + s.slice(1);

13
src/appSettings.ts
View File

@ -4,9 +4,18 @@ import * as fs from "fs"
let settings: Settings
export default function getSettings(){
export default Object.assign(getSettings, {
init,
getSettings
}) as typeof getSettings & {init:typeof init, getSettings: typeof getSettings}
export function getSettings(){
if(settings)return settings
init()
return settings
}
export function init(){
fs.mkdirSync(app.getPath("userData"), {recursive: true})
settings = new Settings(app.getPath("userData"))
return settings
}

2
src/autoStart/win32.ts
View File

@ -39,7 +39,7 @@ import * as windowsUtils from "../windowsUtils"
import appSettings from "../appSettings"
const settings = appSettings();
const settings = appSettings.getSettings();
// TODO: We should use Constant's APP_NAME, but only once
// we set up backwards compat with this.

2
src/common/git.ts
View File

@ -3,7 +3,7 @@ import * as child_process from "child_process"
let commit_id = "{commit}"
const defaultString = Buffer.from([
123, 99, 111,
123, 99, 111,
109, 109, 105,
116, 125
]).toString("utf8")

2
src/index.ts
View File

@ -30,7 +30,7 @@ electron.app.commandLine.appendSwitch('autoplay-policy', 'no-user-gesture-requir
electron.app.commandLine.appendSwitch("no-force-async-hooks-checks");
function setupHardwareAcceleration() {
const settings = appSettings();
const settings = appSettings.getSettings();
//@ts-ignore
const electronMajor = parseInt(process.versions.electron.split('.')[0]);
const allowed = process.env.DISCORD_ENABLE_HARDWARE_ACCELERATION || buildInfo.releaseChannel === 'development' || !(electronMajor === 7 && process.platform === 'darwin');