From 3f7207f4e59825e59c9be50664a3938089d20b80 Mon Sep 17 00:00:00 2001 From: "James@SCF-GC" Date: Sun, 3 Jul 2022 13:23:38 +0200 Subject: [PATCH] vault auto-backup: 03.07.2022 - 13:23:38 Affected files: .obsidian/community-plugins.json .obsidian/graph.json .obsidian/plugins/obsidian-discordrpc/data.json .obsidian/plugins/obsidian-discordrpc/main.js .obsidian/plugins/obsidian-discordrpc/manifest.json .obsidian/workspace --- .obsidian/community-plugins.json | 3 +- .obsidian/graph.json | 2 +- .../plugins/obsidian-discordrpc/data.json | 10 + .obsidian/plugins/obsidian-discordrpc/main.js | 1771 +++++++++++++++++ .../plugins/obsidian-discordrpc/manifest.json | 9 + .obsidian/workspace | 9 +- 6 files changed, 1797 insertions(+), 7 deletions(-) create mode 100644 .obsidian/plugins/obsidian-discordrpc/data.json create mode 100644 .obsidian/plugins/obsidian-discordrpc/main.js create mode 100644 .obsidian/plugins/obsidian-discordrpc/manifest.json diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index fe6546a..81c7752 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -8,5 +8,6 @@ "obsidian-dialogue-plugin", "obsidian-pandoc", "obsidian-image-toolkit", - "obsidian-icons-plugin" + "obsidian-icons-plugin", + "obsidian-discordrpc" ] \ No newline at end of file diff --git a/.obsidian/graph.json b/.obsidian/graph.json index b477248..3494e3d 100644 --- a/.obsidian/graph.json +++ b/.obsidian/graph.json @@ -17,6 +17,6 @@ "repelStrength": 20, "linkStrength": 1, "linkDistance": 315, - "scale": 0.34965970272166447, + "scale": 0.3496597027216647, "close": true } \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-discordrpc/data.json b/.obsidian/plugins/obsidian-discordrpc/data.json new file mode 100644 index 0000000..3b206df --- /dev/null +++ b/.obsidian/plugins/obsidian-discordrpc/data.json @@ -0,0 +1,10 @@ +{ + "showVaultName": true, + "showCurrentFileName": true, + "showPopups": true, + "customVaultName": "", + "showFileExtension": true, + "useLoadedTime": true, + "connectOnStart": true, + "autoHideStatusBar": true +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-discordrpc/main.js b/.obsidian/plugins/obsidian-discordrpc/main.js new file mode 100644 index 0000000..a4ca9d8 --- /dev/null +++ b/.obsidian/plugins/obsidian-discordrpc/main.js @@ -0,0 +1,1771 @@ +'use strict'; + +var require$$0 = require('electron'); +var EventEmitter = require('events'); +var require$$0$1 = require('timers'); +var net = require('net'); +var obsidian = require('obsidian'); + +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + +var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); +var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter); +var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1); +var net__default = /*#__PURE__*/_interopDefaultLegacy(net); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); +}; + +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +function __generator(thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +} + +var _nodeResolve_empty = {}; + +var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({ + __proto__: null, + 'default': _nodeResolve_empty +}); + +function createCommonjsModule(fn, basedir, module) { + return module = { + path: basedir, + exports: {}, + require: function (path, base) { + return commonjsRequire(path, (base === undefined || base === null) ? module.path : base); + } + }, fn(module, module.exports), module.exports; +} + +function getAugmentedNamespace(n) { + if (n.__esModule) return n; + var a = Object.defineProperty({}, '__esModule', {value: true}); + Object.keys(n).forEach(function (k) { + var d = Object.getOwnPropertyDescriptor(n, k); + Object.defineProperty(a, k, d.get ? d : { + enumerable: true, + get: function () { + return n[k]; + } + }); + }); + return a; +} + +function commonjsRequire () { + throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs'); +} + +var require$$1 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1); + +let register; +try { + const { app } = require$$0__default['default']; + register = app.setAsDefaultProtocolClient.bind(app); +} catch (err) { + try { + register = require$$1; + } catch (e) {} // eslint-disable-line no-empty +} + +if (typeof register !== 'function') { + register = () => false; +} + +function pid() { + if (typeof process !== 'undefined') { + return process.pid; + } + return null; +} + +const uuid4122 = () => { + let uuid = ''; + for (let i = 0; i < 32; i += 1) { + if (i === 8 || i === 12 || i === 16 || i === 20) { + uuid += '-'; + } + let n; + if (i === 12) { + n = 4; + } else { + const random = Math.random() * 16 | 0; + if (i === 16) { + n = (random & 3) | 0; + } else { + n = random; + } + } + uuid += n.toString(16); + } + return uuid; +}; + +var util = { + pid, + register, + uuid: uuid4122, +}; + +var browser$2 = createCommonjsModule(function (module, exports) { + +// ref: https://github.com/tc39/proposal-global +var getGlobal = function () { + // the only reliable means to get the global object is + // `Function('return this')()` + // However, this causes CSP violations in Chrome apps. + if (typeof self !== 'undefined') { return self; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + throw new Error('unable to locate global object'); +}; + +var global = getGlobal(); + +module.exports = exports = global.fetch; + +// Needed for TypeScript and Webpack. +if (global.fetch) { + exports.default = global.fetch.bind(global); +} + +exports.Headers = global.Headers; +exports.Request = global.Request; +exports.Response = global.Response; +}); + +const { uuid: uuid$1 } = util; + +const OPCodes = { + HANDSHAKE: 0, + FRAME: 1, + CLOSE: 2, + PING: 3, + PONG: 4, +}; + +function getIPCPath(id) { + if (process.platform === 'win32') { + return `\\\\?\\pipe\\discord-ipc-${id}`; + } + const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP } } = process; + const prefix = XDG_RUNTIME_DIR || TMPDIR || TMP || TEMP || '/tmp'; + return `${prefix.replace(/\/$/, '')}/discord-ipc-${id}`; +} + +function getIPC(id = 0) { + return new Promise((resolve, reject) => { + const path = getIPCPath(id); + const onerror = () => { + if (id < 10) { + resolve(getIPC(id + 1)); + } else { + reject(new Error('Could not connect')); + } + }; + const sock = net__default['default'].createConnection(path, () => { + sock.removeListener('error', onerror); + resolve(sock); + }); + sock.once('error', onerror); + }); +} + +async function findEndpoint(tries = 0) { + if (tries > 30) { + throw new Error('Could not find endpoint'); + } + const endpoint = `http://127.0.0.1:${6463 + (tries % 10)}`; + try { + const r = await browser$2(endpoint); + if (r.status === 404) { + return endpoint; + } + return findEndpoint(tries + 1); + } catch (e) { + return findEndpoint(tries + 1); + } +} + +function encode(op, data) { + data = JSON.stringify(data); + const len = Buffer.byteLength(data); + const packet = Buffer.alloc(8 + len); + packet.writeInt32LE(op, 0); + packet.writeInt32LE(len, 4); + packet.write(data, 8, len); + return packet; +} + +const working = { + full: '', + op: undefined, +}; + +function decode(socket, callback) { + const packet = socket.read(); + if (!packet) { + return; + } + + let { op } = working; + let raw; + if (working.full === '') { + op = working.op = packet.readInt32LE(0); + const len = packet.readInt32LE(4); + raw = packet.slice(8, len + 8); + } else { + raw = packet.toString(); + } + + try { + const data = JSON.parse(working.full + raw); + callback({ op, data }); // eslint-disable-line callback-return + working.full = ''; + working.op = undefined; + } catch (err) { + working.full += raw; + } + + decode(socket, callback); +} + +class IPCTransport extends EventEmitter__default['default'] { + constructor(client) { + super(); + this.client = client; + this.socket = null; + } + + async connect() { + const socket = this.socket = await getIPC(); + socket.on('close', this.onClose.bind(this)); + socket.on('error', this.onClose.bind(this)); + this.emit('open'); + socket.write(encode(OPCodes.HANDSHAKE, { + v: 1, + client_id: this.client.clientId, + })); + socket.pause(); + socket.on('readable', () => { + decode(socket, ({ op, data }) => { + switch (op) { + case OPCodes.PING: + this.send(data, OPCodes.PONG); + break; + case OPCodes.FRAME: + if (!data) { + return; + } + if (data.cmd === 'AUTHORIZE' && data.evt !== 'ERROR') { + findEndpoint() + .then((endpoint) => { + this.client.request.endpoint = endpoint; + }) + .catch((e) => { + this.client.emit('error', e); + }); + } + this.emit('message', data); + break; + case OPCodes.CLOSE: + this.emit('close', data); + break; + default: + break; + } + }); + }); + } + + onClose(e) { + this.emit('close', e); + } + + send(data, op = OPCodes.FRAME) { + this.socket.write(encode(op, data)); + } + + async close() { + return new Promise((r) => { + this.once('close', r); + this.send({}, OPCodes.CLOSE); + this.socket.end(); + }); + } + + ping() { + this.send(uuid$1(), OPCodes.PING); + } +} + +var ipc = IPCTransport; +var encode_1 = encode; +var decode_1 = decode; +ipc.encode = encode_1; +ipc.decode = decode_1; + +function keyMirror(arr) { + const tmp = {}; + for (const value of arr) { + tmp[value] = value; + } + return tmp; +} + + +var browser$1 = typeof window !== 'undefined'; + +var RPCCommands$1 = keyMirror([ + 'DISPATCH', + 'AUTHORIZE', + 'AUTHENTICATE', + 'GET_GUILD', + 'GET_GUILDS', + 'GET_CHANNEL', + 'GET_CHANNELS', + 'CREATE_CHANNEL_INVITE', + 'GET_RELATIONSHIPS', + 'GET_USER', + 'SUBSCRIBE', + 'UNSUBSCRIBE', + 'SET_USER_VOICE_SETTINGS', + 'SET_USER_VOICE_SETTINGS_2', + 'SELECT_VOICE_CHANNEL', + 'GET_SELECTED_VOICE_CHANNEL', + 'SELECT_TEXT_CHANNEL', + 'GET_VOICE_SETTINGS', + 'SET_VOICE_SETTINGS_2', + 'SET_VOICE_SETTINGS', + 'CAPTURE_SHORTCUT', + 'SET_ACTIVITY', + 'SEND_ACTIVITY_JOIN_INVITE', + 'CLOSE_ACTIVITY_JOIN_REQUEST', + 'ACTIVITY_INVITE_USER', + 'ACCEPT_ACTIVITY_INVITE', + 'INVITE_BROWSER', + 'DEEP_LINK', + 'CONNECTIONS_CALLBACK', + 'BRAINTREE_POPUP_BRIDGE_CALLBACK', + 'GIFT_CODE_BROWSER', + 'GUILD_TEMPLATE_BROWSER', + 'OVERLAY', + 'BROWSER_HANDOFF', + 'SET_CERTIFIED_DEVICES', + 'GET_IMAGE', + 'CREATE_LOBBY', + 'UPDATE_LOBBY', + 'DELETE_LOBBY', + 'UPDATE_LOBBY_MEMBER', + 'CONNECT_TO_LOBBY', + 'DISCONNECT_FROM_LOBBY', + 'SEND_TO_LOBBY', + 'SEARCH_LOBBIES', + 'CONNECT_TO_LOBBY_VOICE', + 'DISCONNECT_FROM_LOBBY_VOICE', + 'SET_OVERLAY_LOCKED', + 'OPEN_OVERLAY_ACTIVITY_INVITE', + 'OPEN_OVERLAY_GUILD_INVITE', + 'OPEN_OVERLAY_VOICE_SETTINGS', + 'VALIDATE_APPLICATION', + 'GET_ENTITLEMENT_TICKET', + 'GET_APPLICATION_TICKET', + 'START_PURCHASE', + 'GET_SKUS', + 'GET_ENTITLEMENTS', + 'GET_NETWORKING_CONFIG', + 'NETWORKING_SYSTEM_METRICS', + 'NETWORKING_PEER_METRICS', + 'NETWORKING_CREATE_TOKEN', + 'SET_USER_ACHIEVEMENT', + 'GET_USER_ACHIEVEMENTS', +]); + +var RPCEvents$1 = keyMirror([ + 'CURRENT_USER_UPDATE', + 'GUILD_STATUS', + 'GUILD_CREATE', + 'CHANNEL_CREATE', + 'RELATIONSHIP_UPDATE', + 'VOICE_CHANNEL_SELECT', + 'VOICE_STATE_CREATE', + 'VOICE_STATE_DELETE', + 'VOICE_STATE_UPDATE', + 'VOICE_SETTINGS_UPDATE', + 'VOICE_SETTINGS_UPDATE_2', + 'VOICE_CONNECTION_STATUS', + 'SPEAKING_START', + 'SPEAKING_STOP', + 'GAME_JOIN', + 'GAME_SPECTATE', + 'ACTIVITY_JOIN', + 'ACTIVITY_JOIN_REQUEST', + 'ACTIVITY_SPECTATE', + 'ACTIVITY_INVITE', + 'NOTIFICATION_CREATE', + 'MESSAGE_CREATE', + 'MESSAGE_UPDATE', + 'MESSAGE_DELETE', + 'LOBBY_DELETE', + 'LOBBY_UPDATE', + 'LOBBY_MEMBER_CONNECT', + 'LOBBY_MEMBER_DISCONNECT', + 'LOBBY_MEMBER_UPDATE', + 'LOBBY_MESSAGE', + 'CAPTURE_SHORTCUT_CHANGE', + 'OVERLAY', + 'OVERLAY_UPDATE', + 'ENTITLEMENT_CREATE', + 'ENTITLEMENT_DELETE', + 'USER_ACHIEVEMENT_UPDATE', + 'READY', + 'ERROR', +]); + +var RPCErrors = { + CAPTURE_SHORTCUT_ALREADY_LISTENING: 5004, + GET_GUILD_TIMED_OUT: 5002, + INVALID_ACTIVITY_JOIN_REQUEST: 4012, + INVALID_ACTIVITY_SECRET: 5005, + INVALID_CHANNEL: 4005, + INVALID_CLIENTID: 4007, + INVALID_COMMAND: 4002, + INVALID_ENTITLEMENT: 4015, + INVALID_EVENT: 4004, + INVALID_GIFT_CODE: 4016, + INVALID_GUILD: 4003, + INVALID_INVITE: 4011, + INVALID_LOBBY: 4013, + INVALID_LOBBY_SECRET: 4014, + INVALID_ORIGIN: 4008, + INVALID_PAYLOAD: 4000, + INVALID_PERMISSIONS: 4006, + INVALID_TOKEN: 4009, + INVALID_USER: 4010, + LOBBY_FULL: 5007, + NO_ELIGIBLE_ACTIVITY: 5006, + OAUTH2_ERROR: 5000, + PURCHASE_CANCELED: 5008, + PURCHASE_ERROR: 5009, + RATE_LIMITED: 5011, + SELECT_CHANNEL_TIMED_OUT: 5001, + SELECT_VOICE_FORCE_REQUIRED: 5003, + SERVICE_UNAVAILABLE: 1001, + TRANSACTION_ABORTED: 1002, + UNAUTHORIZED_FOR_ACHIEVEMENT: 5010, + UNKNOWN_ERROR: 1000, +}; + +var RPCCloseCodes = { + CLOSE_NORMAL: 1000, + CLOSE_UNSUPPORTED: 1003, + CLOSE_ABNORMAL: 1006, + INVALID_CLIENTID: 4000, + INVALID_ORIGIN: 4001, + RATELIMITED: 4002, + TOKEN_REVOKED: 4003, + INVALID_VERSION: 4004, + INVALID_ENCODING: 4005, +}; + +var LobbyTypes = { + PRIVATE: 1, + PUBLIC: 2, +}; + +var RelationshipTypes$1 = { + NONE: 0, + FRIEND: 1, + BLOCKED: 2, + PENDING_INCOMING: 3, + PENDING_OUTGOING: 4, + IMPLICIT: 5, +}; + +var constants = { + browser: browser$1, + RPCCommands: RPCCommands$1, + RPCEvents: RPCEvents$1, + RPCErrors: RPCErrors, + RPCCloseCodes: RPCCloseCodes, + LobbyTypes: LobbyTypes, + RelationshipTypes: RelationshipTypes$1 +}; + +const { browser } = constants; + +// eslint-disable-next-line +const WebSocket = browser ? window.WebSocket : require$$1; + +const pack = (d) => JSON.stringify(d); +const unpack = (s) => JSON.parse(s); + +class WebSocketTransport extends EventEmitter__default['default'] { + constructor(client) { + super(); + this.client = client; + this.ws = null; + this.tries = 0; + } + + async connect() { + const port = 6463 + (this.tries % 10); + this.tries += 1; + + this.ws = new WebSocket( + `ws://127.0.0.1:${port}/?v=1&client_id=${this.client.clientId}`, + browser ? undefined : { origin: this.client.options.origin }, + ); + this.ws.onopen = this.onOpen.bind(this); + this.ws.onclose = this.onClose.bind(this); + this.ws.onerror = this.onError.bind(this); + this.ws.onmessage = this.onMessage.bind(this); + } + + onOpen() { + this.emit('open'); + } + + onClose(event) { + if (!event.wasClean) { + return; + } + this.emit('close', event); + } + + onError(event) { + try { + this.ws.close(); + } catch {} // eslint-disable-line no-empty + + if (this.tries > 20) { + this.emit('error', event.error); + } else { + setTimeout(() => { + this.connect(); + }, 250); + } + } + + onMessage(event) { + this.emit('message', unpack(event.data)); + } + + send(data) { + this.ws.send(pack(data)); + } + + ping() {} // eslint-disable-line no-empty-function + + close() { + return new Promise((r) => { + this.once('close', r); + this.ws.close(); + }); + } +} + +var websocket = WebSocketTransport; + +var transports = { + ipc: ipc, + websocket: websocket, +}; + +const { setTimeout: setTimeout$1, clearTimeout } = require$$0__default$1['default']; + + +const { RPCCommands, RPCEvents, RelationshipTypes } = constants; +const { pid: getPid, uuid } = util; + +function subKey(event, args) { + return `${event}${JSON.stringify(args)}`; +} + +/** + * @typedef {RPCClientOptions} + * @extends {ClientOptions} + * @prop {string} transport RPC transport. one of `ipc` or `websocket` + */ + +/** + * The main hub for interacting with Discord RPC + * @extends {BaseClient} + */ +class RPCClient extends EventEmitter__default['default'] { + /** + * @param {RPCClientOptions} [options] Options for the client. + * You must provide a transport + */ + constructor(options = {}) { + super(); + + this.options = options; + + this.accessToken = null; + this.clientId = null; + + /** + * Application used in this client + * @type {?ClientApplication} + */ + this.application = null; + + /** + * User used in this application + * @type {?User} + */ + this.user = null; + + const Transport = transports[options.transport]; + if (!Transport) { + throw new TypeError('RPC_INVALID_TRANSPORT', options.transport); + } + + this.fetch = (method, path, { data, query } = {}) => + browser$2(`${this.fetch.endpoint}${path}${query ? new URLSearchParams(query) : ''}`, { + method, + body: data, + headers: { + Authorization: `Bearer ${this.accessToken}`, + }, + }).then(async (r) => { + const body = await r.json(); + if (!r.ok) { + const e = new Error(r.status); + e.body = body; + throw e; + } + return body; + }); + + this.fetch.endpoint = 'https://discord.com/api'; + + /** + * Raw transport userd + * @type {RPCTransport} + * @private + */ + this.transport = new Transport(this); + this.transport.on('message', this._onRpcMessage.bind(this)); + + /** + * Map of nonces being expected from the transport + * @type {Map} + * @private + */ + this._expecting = new Map(); + + /** + * Map of current subscriptions + * @type {Map} + * @private + */ + this._subscriptions = new Map(); + + this._connectPromise = undefined; + } + + /** + * Search and connect to RPC + */ + connect(clientId) { + if (this._connectPromise) { + return this._connectPromise; + } + this._connectPromise = new Promise((resolve, reject) => { + this.clientId = clientId; + const timeout = setTimeout$1(() => reject(new Error('RPC_CONNECTION_TIMEOUT')), 10e3); + timeout.unref(); + this.once('connected', () => { + clearTimeout(timeout); + resolve(this); + }); + this.transport.once('close', () => { + this._expecting.forEach((e) => { + e.reject(new Error('connection closed')); + }); + this.emit('disconnected'); + reject(new Error('connection closed')); + }); + this.transport.connect().catch(reject); + }); + return this._connectPromise; + } + + /** + * @typedef {RPCLoginOptions} + * @param {string} clientId Client ID + * @param {string} [clientSecret] Client secret + * @param {string} [accessToken] Access token + * @param {string} [rpcToken] RPC token + * @param {string} [tokenEndpoint] Token endpoint + * @param {string[]} [scopes] Scopes to authorize with + */ + + /** + * Performs authentication flow. Automatically calls Client#connect if needed. + * @param {RPCLoginOptions} options Options for authentication. + * At least one property must be provided to perform login. + * @example client.login({ clientId: '1234567', clientSecret: 'abcdef123' }); + * @returns {Promise} + */ + async login(options = {}) { + let { clientId, accessToken } = options; + await this.connect(clientId); + if (!options.scopes) { + this.emit('ready'); + return this; + } + if (!accessToken) { + accessToken = await this.authorize(options); + } + return this.authenticate(accessToken); + } + + /** + * Request + * @param {string} cmd Command + * @param {Object} [args={}] Arguments + * @param {string} [evt] Event + * @returns {Promise} + * @private + */ + request(cmd, args, evt) { + return new Promise((resolve, reject) => { + const nonce = uuid(); + this.transport.send({ cmd, args, evt, nonce }); + this._expecting.set(nonce, { resolve, reject }); + }); + } + + /** + * Message handler + * @param {Object} message message + * @private + */ + _onRpcMessage(message) { + if (message.cmd === RPCCommands.DISPATCH && message.evt === RPCEvents.READY) { + if (message.data.user) { + this.user = message.data.user; + } + this.emit('connected'); + } else if (this._expecting.has(message.nonce)) { + const { resolve, reject } = this._expecting.get(message.nonce); + if (message.evt === 'ERROR') { + const e = new Error(message.data.message); + e.code = message.data.code; + e.data = message.data; + reject(e); + } else { + resolve(message.data); + } + this._expecting.delete(message.nonce); + } else { + const subid = subKey(message.evt, message.args); + if (!this._subscriptions.has(subid)) { + return; + } + this._subscriptions.get(subid)(message.data); + } + } + + /** + * Authorize + * @param {Object} options options + * @returns {Promise} + * @private + */ + async authorize({ scopes, clientSecret, rpcToken, redirectUri } = {}) { + if (clientSecret && rpcToken === true) { + const body = await this.fetch('POST', '/oauth2/token/rpc', { + data: new URLSearchParams({ + client_id: this.clientId, + client_secret: clientSecret, + }), + }); + rpcToken = body.rpc_token; + } + + const { code } = await this.request('AUTHORIZE', { + scopes, + client_id: this.clientId, + rpc_token: rpcToken, + }); + + const response = await this.fetch('POST', '/oauth2/token', { + data: new URLSearchParams({ + client_id: this.clientId, + client_secret: clientSecret, + code, + grant_type: 'authorization_code', + redirect_uri: redirectUri, + }), + }); + + return response.access_token; + } + + /** + * Authenticate + * @param {string} accessToken access token + * @returns {Promise} + * @private + */ + authenticate(accessToken) { + return this.request('AUTHENTICATE', { access_token: accessToken }) + .then(({ application, user }) => { + this.accessToken = accessToken; + this.application = application; + this.user = user; + this.emit('ready'); + return this; + }); + } + + + /** + * Fetch a guild + * @param {Snowflake} id Guild ID + * @param {number} [timeout] Timeout request + * @returns {Promise} + */ + getGuild(id, timeout) { + return this.request(RPCCommands.GET_GUILD, { guild_id: id, timeout }); + } + + /** + * Fetch all guilds + * @param {number} [timeout] Timeout request + * @returns {Promise>} + */ + getGuilds(timeout) { + return this.request(RPCCommands.GET_GUILDS, { timeout }); + } + + /** + * Get a channel + * @param {Snowflake} id Channel ID + * @param {number} [timeout] Timeout request + * @returns {Promise} + */ + getChannel(id, timeout) { + return this.request(RPCCommands.GET_CHANNEL, { channel_id: id, timeout }); + } + + /** + * Get all channels + * @param {Snowflake} [id] Guild ID + * @param {number} [timeout] Timeout request + * @returns {Promise>} + */ + async getChannels(id, timeout) { + const { channels } = await this.request(RPCCommands.GET_CHANNELS, { + timeout, + guild_id: id, + }); + return channels; + } + + /** + * @typedef {CertifiedDevice} + * @prop {string} type One of `AUDIO_INPUT`, `AUDIO_OUTPUT`, `VIDEO_INPUT` + * @prop {string} uuid This device's Windows UUID + * @prop {object} vendor Vendor information + * @prop {string} vendor.name Vendor's name + * @prop {string} vendor.url Vendor's url + * @prop {object} model Model information + * @prop {string} model.name Model's name + * @prop {string} model.url Model's url + * @prop {string[]} related Array of related product's Windows UUIDs + * @prop {boolean} echoCancellation If the device has echo cancellation + * @prop {boolean} noiseSuppression If the device has noise suppression + * @prop {boolean} automaticGainControl If the device has automatic gain control + * @prop {boolean} hardwareMute If the device has a hardware mute + */ + + /** + * Tell discord which devices are certified + * @param {CertifiedDevice[]} devices Certified devices to send to discord + * @returns {Promise} + */ + setCertifiedDevices(devices) { + return this.request(RPCCommands.SET_CERTIFIED_DEVICES, { + devices: devices.map((d) => ({ + type: d.type, + id: d.uuid, + vendor: d.vendor, + model: d.model, + related: d.related, + echo_cancellation: d.echoCancellation, + noise_suppression: d.noiseSuppression, + automatic_gain_control: d.automaticGainControl, + hardware_mute: d.hardwareMute, + })), + }); + } + + /** + * @typedef {UserVoiceSettings} + * @prop {Snowflake} id ID of the user these settings apply to + * @prop {?Object} [pan] Pan settings, an object with `left` and `right` set between + * 0.0 and 1.0, inclusive + * @prop {?number} [volume=100] The volume + * @prop {bool} [mute] If the user is muted + */ + + /** + * Set the voice settings for a user, by id + * @param {Snowflake} id ID of the user to set + * @param {UserVoiceSettings} settings Settings + * @returns {Promise} + */ + setUserVoiceSettings(id, settings) { + return this.request(RPCCommands.SET_USER_VOICE_SETTINGS, { + user_id: id, + pan: settings.pan, + mute: settings.mute, + volume: settings.volume, + }); + } + + /** + * Move the user to a voice channel + * @param {Snowflake} id ID of the voice channel + * @param {Object} [options] Options + * @param {number} [options.timeout] Timeout for the command + * @param {boolean} [options.force] Force this move. This should only be done if you + * have explicit permission from the user. + * @returns {Promise} + */ + selectVoiceChannel(id, { timeout, force = false } = {}) { + return this.request(RPCCommands.SELECT_VOICE_CHANNEL, { channel_id: id, timeout, force }); + } + + /** + * Move the user to a text channel + * @param {Snowflake} id ID of the voice channel + * @param {Object} [options] Options + * @param {number} [options.timeout] Timeout for the command + * have explicit permission from the user. + * @returns {Promise} + */ + selectTextChannel(id, { timeout } = {}) { + return this.request(RPCCommands.SELECT_TEXT_CHANNEL, { channel_id: id, timeout }); + } + + /** + * Get current voice settings + * @returns {Promise} + */ + getVoiceSettings() { + return this.request(RPCCommands.GET_VOICE_SETTINGS) + .then((s) => ({ + automaticGainControl: s.automatic_gain_control, + echoCancellation: s.echo_cancellation, + noiseSuppression: s.noise_suppression, + qos: s.qos, + silenceWarning: s.silence_warning, + deaf: s.deaf, + mute: s.mute, + input: { + availableDevices: s.input.available_devices, + device: s.input.device_id, + volume: s.input.volume, + }, + output: { + availableDevices: s.output.available_devices, + device: s.output.device_id, + volume: s.output.volume, + }, + mode: { + type: s.mode.type, + autoThreshold: s.mode.auto_threshold, + threshold: s.mode.threshold, + shortcut: s.mode.shortcut, + delay: s.mode.delay, + }, + })); + } + + /** + * Set current voice settings, overriding the current settings until this session disconnects. + * This also locks the settings for any other rpc sessions which may be connected. + * @param {Object} args Settings + * @returns {Promise} + */ + setVoiceSettings(args) { + return this.request(RPCCommands.SET_VOICE_SETTINGS, { + automatic_gain_control: args.automaticGainControl, + echo_cancellation: args.echoCancellation, + noise_suppression: args.noiseSuppression, + qos: args.qos, + silence_warning: args.silenceWarning, + deaf: args.deaf, + mute: args.mute, + input: args.input ? { + device_id: args.input.device, + volume: args.input.volume, + } : undefined, + output: args.output ? { + device_id: args.output.device, + volume: args.output.volume, + } : undefined, + mode: args.mode ? { + mode: args.mode.type, + auto_threshold: args.mode.autoThreshold, + threshold: args.mode.threshold, + shortcut: args.mode.shortcut, + delay: args.mode.delay, + } : undefined, + }); + } + + /** + * Capture a shortcut using the client + * The callback takes (key, stop) where `stop` is a function that will stop capturing. + * This `stop` function must be called before disconnecting or else the user will have + * to restart their client. + * @param {Function} callback Callback handling keys + * @returns {Promise} + */ + captureShortcut(callback) { + const subid = subKey(RPCEvents.CAPTURE_SHORTCUT_CHANGE); + const stop = () => { + this._subscriptions.delete(subid); + return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'STOP' }); + }; + this._subscriptions.set(subid, ({ shortcut }) => { + callback(shortcut, stop); + }); + return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'START' }) + .then(() => stop); + } + + /** + * Sets the presence for the logged in user. + * @param {object} args The rich presence to pass. + * @param {number} [pid] The application's process ID. Defaults to the executing process' PID. + * @returns {Promise} + */ + setActivity(args = {}, pid = getPid()) { + let timestamps; + let assets; + let party; + let secrets; + if (args.startTimestamp || args.endTimestamp) { + timestamps = { + start: args.startTimestamp, + end: args.endTimestamp, + }; + if (timestamps.start instanceof Date) { + timestamps.start = Math.round(timestamps.start.getTime()); + } + if (timestamps.end instanceof Date) { + timestamps.end = Math.round(timestamps.end.getTime()); + } + if (timestamps.start > 2147483647000) { + throw new RangeError('timestamps.start must fit into a unix timestamp'); + } + if (timestamps.end > 2147483647000) { + throw new RangeError('timestamps.end must fit into a unix timestamp'); + } + } + if ( + args.largeImageKey || args.largeImageText + || args.smallImageKey || args.smallImageText + ) { + assets = { + large_image: args.largeImageKey, + large_text: args.largeImageText, + small_image: args.smallImageKey, + small_text: args.smallImageText, + }; + } + if (args.partySize || args.partyId || args.partyMax) { + party = { id: args.partyId }; + if (args.partySize || args.partyMax) { + party.size = [args.partySize, args.partyMax]; + } + } + if (args.matchSecret || args.joinSecret || args.spectateSecret) { + secrets = { + match: args.matchSecret, + join: args.joinSecret, + spectate: args.spectateSecret, + }; + } + + return this.request(RPCCommands.SET_ACTIVITY, { + pid, + activity: { + state: args.state, + details: args.details, + timestamps, + assets, + party, + secrets, + buttons: args.buttons, + instance: !!args.instance, + }, + }); + } + + /** + * Clears the currently set presence, if any. This will hide the "Playing X" message + * displayed below the user's name. + * @param {number} [pid] The application's process ID. Defaults to the executing process' PID. + * @returns {Promise} + */ + clearActivity(pid = getPid()) { + return this.request(RPCCommands.SET_ACTIVITY, { + pid, + }); + } + + /** + * Invite a user to join the game the RPC user is currently playing + * @param {User} user The user to invite + * @returns {Promise} + */ + sendJoinInvite(user) { + return this.request(RPCCommands.SEND_ACTIVITY_JOIN_INVITE, { + user_id: user.id || user, + }); + } + + /** + * Request to join the game the user is playing + * @param {User} user The user whose game you want to request to join + * @returns {Promise} + */ + sendJoinRequest(user) { + return this.request(RPCCommands.SEND_ACTIVITY_JOIN_REQUEST, { + user_id: user.id || user, + }); + } + + /** + * Reject a join request from a user + * @param {User} user The user whose request you wish to reject + * @returns {Promise} + */ + closeJoinRequest(user) { + return this.request(RPCCommands.CLOSE_ACTIVITY_JOIN_REQUEST, { + user_id: user.id || user, + }); + } + + createLobby(type, capacity, metadata) { + return this.request(RPCCommands.CREATE_LOBBY, { + type, + capacity, + metadata, + }); + } + + updateLobby(lobby, { type, owner, capacity, metadata } = {}) { + return this.request(RPCCommands.UPDATE_LOBBY, { + id: lobby.id || lobby, + type, + owner_id: (owner && owner.id) || owner, + capacity, + metadata, + }); + } + + deleteLobby(lobby) { + return this.request(RPCCommands.DELETE_LOBBY, { + id: lobby.id || lobby, + }); + } + + connectToLobby(id, secret) { + return this.request(RPCCommands.CONNECT_TO_LOBBY, { + id, + secret, + }); + } + + sendToLobby(lobby, data) { + return this.request(RPCCommands.SEND_TO_LOBBY, { + id: lobby.id || lobby, + data, + }); + } + + disconnectFromLobby(lobby) { + return this.request(RPCCommands.DISCONNECT_FROM_LOBBY, { + id: lobby.id || lobby, + }); + } + + updateLobbyMember(lobby, user, metadata) { + return this.request(RPCCommands.UPDATE_LOBBY_MEMBER, { + lobby_id: lobby.id || lobby, + user_id: user.id || user, + metadata, + }); + } + + getRelationships() { + const types = Object.keys(RelationshipTypes); + return this.request(RPCCommands.GET_RELATIONSHIPS) + .then((o) => o.relationships.map((r) => ({ + ...r, + type: types[r.type], + }))); + } + + /** + * Subscribe to an event + * @param {string} event Name of event e.g. `MESSAGE_CREATE` + * @param {Object} [args] Args for event e.g. `{ channel_id: '1234' }` + * @param {Function} callback Callback when an event for the subscription is triggered + * @returns {Promise} + */ + subscribe(event, args, callback) { + if (!callback && typeof args === 'function') { + callback = args; + args = undefined; + } + return this.request(RPCCommands.SUBSCRIBE, args, event).then(() => { + const subid = subKey(event, args); + this._subscriptions.set(subid, callback); + return { + unsubscribe: () => this.request(RPCCommands.UNSUBSCRIBE, args, event) + .then(() => this._subscriptions.delete(subid)), + }; + }); + } + + /** + * Destroy the client + */ + async destroy() { + await this.transport.close(); + } +} + +var client = RPCClient; + +var src = { + Client: client, + register(id) { + return util.register(`discord-${id}`); + }, +}; + +var Logger = /** @class */ (function () { + function Logger() { + this.plugin = this.plugin; + } + Logger.prototype.log = function (message, showPopups) { + if (showPopups) { + new obsidian.Notice(message); + } + console.log("discordrpc: " + message); + }; + Logger.prototype.logIgnoreNoNotice = function (message) { + new obsidian.Notice(message); + console.log("discordrpc: " + message); + }; + return Logger; +}()); + +var DiscordRPCSettings = /** @class */ (function () { + function DiscordRPCSettings() { + this.showVaultName = true; + this.showCurrentFileName = true; + this.showPopups = true; + this.customVaultName = ""; + this.showFileExtension = false; + this.useLoadedTime = false; + this.connectOnStart = true; + this.autoHideStatusBar = true; + } + return DiscordRPCSettings; +}()); +var PluginState; +(function (PluginState) { + PluginState[PluginState["connected"] = 0] = "connected"; + PluginState[PluginState["connecting"] = 1] = "connecting"; + PluginState[PluginState["disconnected"] = 2] = "disconnected"; +})(PluginState || (PluginState = {})); + +var DiscordRPCSettingsTab = /** @class */ (function (_super) { + __extends(DiscordRPCSettingsTab, _super); + function DiscordRPCSettingsTab() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.logger = new Logger(); + return _this; + } + DiscordRPCSettingsTab.prototype.display = function () { + var _this = this; + var containerEl = this.containerEl; + var plugin = this.plugin; + containerEl.empty(); + containerEl.createEl("h2", { text: "Discord Rich Presence Settings" }); + containerEl.createEl("h3", { text: "Vault Name Settings" }); + new obsidian.Setting(containerEl) + .setName("Show Vault Name") + .setDesc("Enable this to show the name of the vault you are working with.") + .addToggle(function (boolean) { + return boolean.setValue(plugin.settings.showVaultName).onChange(function (value) { + plugin.settings.showVaultName = value; + plugin.saveData(plugin.settings); + if (boolean.getValue()) { + _this.logger.logIgnoreNoNotice("Vault Name is now Visable"); + } + else { + _this.logger.logIgnoreNoNotice("Vault Name is no longer Visable"); + } + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + new obsidian.Setting(containerEl) + .setName("Set Custom Vault Name") + .setDesc("Change the vault name shown publicly. Leave blank to use your actual vault name.") + .addText(function (text) { + return text.setValue(plugin.settings.customVaultName).onChange(function (value) { + plugin.settings.customVaultName = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "File Name Settings" }); + new obsidian.Setting(containerEl) + .setName("Show Current File Name") + .setDesc("Enable this to show the name of the file you are working on.") + .addToggle(function (boolean) { + return boolean + .setValue(plugin.settings.showCurrentFileName) + .onChange(function (value) { + plugin.settings.showCurrentFileName = value; + plugin.saveData(plugin.settings); + if (boolean.getValue()) { + _this.logger.logIgnoreNoNotice("File Name is now Visable"); + } + else { + _this.logger.logIgnoreNoNotice("File Name is no longer Visable"); + } + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + new obsidian.Setting(containerEl) + .setName("Show File Extension") + .setDesc("Enable this to show file extension.") + .addToggle(function (boolean) { + return boolean + .setValue(plugin.settings.showFileExtension) + .onChange(function (value) { + plugin.settings.showFileExtension = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Time Settings" }); + new obsidian.Setting(containerEl) + .setName("Use Obsidian Total Time") + .setDesc("Enable to use the total time you have been using Obsidian, instead of the time spent editing a single file.") + .addToggle(function (boolean) { + boolean.setValue(plugin.settings.useLoadedTime).onChange(function (value) { + plugin.settings.useLoadedTime = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Status Bar Settings" }); + new obsidian.Setting(containerEl) + .setName("Automatically hide Status Bar") + .setDesc("Automatically hide status bar after successfully connecting to Discord.") + .addToggle(function (boolean) { + boolean.setValue(plugin.settings.autoHideStatusBar).onChange(function (value) { + plugin.settings.autoHideStatusBar = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Startup Settings" }); + new obsidian.Setting(containerEl) + .setName("Automatically Connect to Discord") + .setDesc("Automatically connect to Discord on startup. You can always click the status bar to manually connect.") + .addToggle(function (boolean) { + boolean.setValue(plugin.settings.connectOnStart).onChange(function (value) { + plugin.settings.connectOnStart = value; + plugin.saveData(plugin.settings); + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + containerEl.createEl("h3", { text: "Notice Settings" }); + new obsidian.Setting(containerEl) + .setName("Show Notices") + .setDesc("Enable this to show connection Notices.") + .addToggle(function (boolean) { + return boolean.setValue(plugin.settings.showPopups).onChange(function (value) { + plugin.settings.showPopups = value; + plugin.saveData(plugin.settings); + if (boolean.getValue()) { + _this.logger.logIgnoreNoNotice("Notices Enabled"); + } + else { + _this.logger.logIgnoreNoNotice("Notices Disabled"); + } + plugin.setActivity(_this.app.vault.getName(), plugin.currentFile.basename, plugin.currentFile.extension); + }); + }); + }; + return DiscordRPCSettingsTab; +}(obsidian.PluginSettingTab)); + +var StatusBar = /** @class */ (function () { + function StatusBar(statusBarEl) { + this.statusBarEl = statusBarEl; + } + StatusBar.prototype.displayState = function (state, autoHide) { + switch (state) { + case PluginState.connected: + this.displayConnected(autoHide ? 10000 : 0); + break; + case PluginState.connecting: + this.statusBarEl.setText("Connecting to Discord..."); + break; + case PluginState.disconnected: + this.statusBarEl.setText("\uD83D\uDDD8 Reconnect to Discord"); + break; + } + }; + StatusBar.prototype.displayConnected = function (timeout) { + var _this = this; + this.statusBarEl.setText("\uD83C\uDF0D Connected to Discord"); + if (timeout && timeout > 0) { + window.setTimeout(function () { + _this.statusBarEl.setText(""); + }, timeout); + } + else { + window.setTimeout(function () { + _this.statusBarEl.setText("\uD83C\uDF0D"); + }, 5000); + } + }; + return StatusBar; +}()); + +var ObsidianDiscordRPC = /** @class */ (function (_super) { + __extends(ObsidianDiscordRPC, _super); + function ObsidianDiscordRPC() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.logger = new Logger(); + return _this; + } + ObsidianDiscordRPC.prototype.setState = function (state) { + this.state = state; + }; + ObsidianDiscordRPC.prototype.getState = function () { + return this.state; + }; + ObsidianDiscordRPC.prototype.getApp = function () { + return this.app; + }; + ObsidianDiscordRPC.prototype.getPluginManifest = function () { + return this.manifest; + }; + ObsidianDiscordRPC.prototype.onload = function () { + return __awaiter(this, void 0, void 0, function () { + var statusBarEl, _a, activeLeaf_1, files; + var _this = this; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + statusBarEl = this.addStatusBarItem(); + this.statusBar = new StatusBar(statusBarEl); + _a = this; + return [4 /*yield*/, this.loadData()]; + case 1: + _a.settings = (_b.sent()) || new DiscordRPCSettings(); + this.registerEvent(this.app.workspace.on("file-open", this.onFileOpen, this)); + this.registerDomEvent(statusBarEl, "click", function () { return __awaiter(_this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!(this.getState() == PluginState.disconnected)) return [3 /*break*/, 2]; + return [4 /*yield*/, this.connectDiscord()]; + case 1: + _a.sent(); + return [3 /*break*/, 4]; + case 2: + if (!(this.getState() == PluginState.connected)) return [3 /*break*/, 4]; + return [4 /*yield*/, this.disconnectDiscord()]; + case 3: + _a.sent(); + _a.label = 4; + case 4: return [2 /*return*/]; + } + }); + }); }); + this.addSettingTab(new DiscordRPCSettingsTab(this.app, this)); + this.addCommand({ + id: "reconnect-discord", + name: "Reconnect to Discord", + callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.connectDiscord()]; + case 1: return [2 /*return*/, _a.sent()]; + } + }); }); }, + }); + this.addCommand({ + id: "disconnect-discord", + name: "Disconnect from Discord", + callback: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.disconnectDiscord()]; + case 1: return [2 /*return*/, _a.sent()]; + } + }); }); }, + }); + if (!this.settings.connectOnStart) return [3 /*break*/, 3]; + return [4 /*yield*/, this.connectDiscord()]; + case 2: + _b.sent(); + activeLeaf_1 = this.app.workspace.activeLeaf; + files = this.app.vault.getMarkdownFiles(); + files.forEach(function (file) { + if (file.basename === activeLeaf_1.getDisplayText()) { + _this.onFileOpen(file); + } + }); + return [3 /*break*/, 4]; + case 3: + this.setState(PluginState.disconnected); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + _b.label = 4; + case 4: return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.onFileOpen = function (file) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + this.currentFile = file; + if (!(this.getState() === PluginState.connected)) return [3 /*break*/, 2]; + return [4 /*yield*/, this.setActivity(this.app.vault.getName(), file.basename, file.extension)]; + case 1: + _a.sent(); + _a.label = 2; + case 2: return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.onunload = function () { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.saveData(this.settings)]; + case 1: + _a.sent(); + this.rpc.clearActivity(); + this.rpc.destroy(); + return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.connectDiscord = function () { + return __awaiter(this, void 0, void 0, function () { + var _this = this; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + this.loadedTime = new Date(); + this.rpc = new src.Client({ + transport: "ipc", + }); + this.setState(PluginState.connecting); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + this.rpc.once("ready", function () { + _this.setState(PluginState.connected); + _this.statusBar.displayState(_this.getState(), _this.settings.autoHideStatusBar); + _this.logger.log("Connected to Discord", _this.settings.showPopups); + }); + _a.label = 1; + case 1: + _a.trys.push([1, 4, , 5]); + return [4 /*yield*/, this.rpc.login({ + clientId: "763813185022197831", + })]; + case 2: + _a.sent(); + return [4 /*yield*/, this.setActivity(this.app.vault.getName(), "...", "")]; + case 3: + _a.sent(); + return [3 /*break*/, 5]; + case 4: + _a.sent(); + this.setState(PluginState.disconnected); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + this.logger.log("Failed to connect to Discord", this.settings.showPopups); + return [3 /*break*/, 5]; + case 5: return [2 /*return*/]; + } + }); + }); + }; + ObsidianDiscordRPC.prototype.disconnectDiscord = function () { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a) { + this.rpc.clearActivity(); + this.rpc.destroy(); + this.setState(PluginState.disconnected); + this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar); + this.logger.log("Disconnected from Discord", this.settings.showPopups); + return [2 /*return*/]; + }); + }); + }; + ObsidianDiscordRPC.prototype.setActivity = function (vaultName, fileName, fileExtension) { + return __awaiter(this, void 0, void 0, function () { + var vault, file, date; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!(this.getState() === PluginState.connected)) return [3 /*break*/, 8]; + vault = void 0; + if (this.settings.customVaultName === "") { + vault = vaultName; + } + else { + vault = this.settings.customVaultName; + } + file = void 0; + if (this.settings.showFileExtension) { + file = fileName + "." + fileExtension; + } + else { + file = fileName; + } + date = void 0; + if (this.settings.useLoadedTime) { + date = this.loadedTime; + } + else { + date = new Date(); + } + if (!(this.settings.showVaultName && this.settings.showCurrentFileName)) return [3 /*break*/, 2]; + return [4 /*yield*/, this.rpc.setActivity({ + details: "Editing " + file, + state: "Vault: " + vault, + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 1: + _a.sent(); + return [3 /*break*/, 8]; + case 2: + if (!this.settings.showVaultName) return [3 /*break*/, 4]; + return [4 /*yield*/, this.rpc.setActivity({ + state: "Vault: " + vault, + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 3: + _a.sent(); + return [3 /*break*/, 8]; + case 4: + if (!this.settings.showCurrentFileName) return [3 /*break*/, 6]; + return [4 /*yield*/, this.rpc.setActivity({ + details: "Editing " + file, + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 5: + _a.sent(); + return [3 /*break*/, 8]; + case 6: return [4 /*yield*/, this.rpc.setActivity({ + startTimestamp: date, + largeImageKey: "logo", + largeImageText: "Obsidian", + })]; + case 7: + _a.sent(); + _a.label = 8; + case 8: return [2 /*return*/]; + } + }); + }); + }; + return ObsidianDiscordRPC; +}(obsidian.Plugin)); + +module.exports = ObsidianDiscordRPC; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["../node_modules/tslib/tslib.es6.js","../node_modules/discord-rpc/src/util.js","../node_modules/node-fetch/browser.js","../node_modules/discord-rpc/src/transports/ipc.js","../node_modules/discord-rpc/src/constants.js","../node_modules/discord-rpc/src/transports/websocket.js","../node_modules/discord-rpc/src/transports/index.js","../node_modules/discord-rpc/src/client.js","../node_modules/discord-rpc/src/index.js","../src/logger.ts","../src/settings/settings.ts","../src/settings/settings-tab.ts","../src/status-bar.ts","../src/main.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || from);\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","'use strict';\n\nlet register;\ntry {\n  const { app } = require('electron');\n  register = app.setAsDefaultProtocolClient.bind(app);\n} catch (err) {\n  try {\n    register = require('register-scheme');\n  } catch (e) {} // eslint-disable-line no-empty\n}\n\nif (typeof register !== 'function') {\n  register = () => false;\n}\n\nfunction pid() {\n  if (typeof process !== 'undefined') {\n    return process.pid;\n  }\n  return null;\n}\n\nconst uuid4122 = () => {\n  let uuid = '';\n  for (let i = 0; i < 32; i += 1) {\n    if (i === 8 || i === 12 || i === 16 || i === 20) {\n      uuid += '-';\n    }\n    let n;\n    if (i === 12) {\n      n = 4;\n    } else {\n      const random = Math.random() * 16 | 0;\n      if (i === 16) {\n        n = (random & 3) | 0;\n      } else {\n        n = random;\n      }\n    }\n    uuid += n.toString(16);\n  }\n  return uuid;\n};\n\nmodule.exports = {\n  pid,\n  register,\n  uuid: uuid4122,\n};\n","\"use strict\";\n\n// ref: https://github.com/tc39/proposal-global\nvar getGlobal = function () {\n\t// the only reliable means to get the global object is\n\t// `Function('return this')()`\n\t// However, this causes CSP violations in Chrome apps.\n\tif (typeof self !== 'undefined') { return self; }\n\tif (typeof window !== 'undefined') { return window; }\n\tif (typeof global !== 'undefined') { return global; }\n\tthrow new Error('unable to locate global object');\n}\n\nvar global = getGlobal();\n\nmodule.exports = exports = global.fetch;\n\n// Needed for TypeScript and Webpack.\nif (global.fetch) {\n\texports.default = global.fetch.bind(global);\n}\n\nexports.Headers = global.Headers;\nexports.Request = global.Request;\nexports.Response = global.Response;","'use strict';\n\nconst net = require('net');\nconst EventEmitter = require('events');\nconst fetch = require('node-fetch');\nconst { uuid } = require('../util');\n\nconst OPCodes = {\n  HANDSHAKE: 0,\n  FRAME: 1,\n  CLOSE: 2,\n  PING: 3,\n  PONG: 4,\n};\n\nfunction getIPCPath(id) {\n  if (process.platform === 'win32') {\n    return `\\\\\\\\?\\\\pipe\\\\discord-ipc-${id}`;\n  }\n  const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP } } = process;\n  const prefix = XDG_RUNTIME_DIR || TMPDIR || TMP || TEMP || '/tmp';\n  return `${prefix.replace(/\\/$/, '')}/discord-ipc-${id}`;\n}\n\nfunction getIPC(id = 0) {\n  return new Promise((resolve, reject) => {\n    const path = getIPCPath(id);\n    const onerror = () => {\n      if (id < 10) {\n        resolve(getIPC(id + 1));\n      } else {\n        reject(new Error('Could not connect'));\n      }\n    };\n    const sock = net.createConnection(path, () => {\n      sock.removeListener('error', onerror);\n      resolve(sock);\n    });\n    sock.once('error', onerror);\n  });\n}\n\nasync function findEndpoint(tries = 0) {\n  if (tries > 30) {\n    throw new Error('Could not find endpoint');\n  }\n  const endpoint = `http://127.0.0.1:${6463 + (tries % 10)}`;\n  try {\n    const r = await fetch(endpoint);\n    if (r.status === 404) {\n      return endpoint;\n    }\n    return findEndpoint(tries + 1);\n  } catch (e) {\n    return findEndpoint(tries + 1);\n  }\n}\n\nfunction encode(op, data) {\n  data = JSON.stringify(data);\n  const len = Buffer.byteLength(data);\n  const packet = Buffer.alloc(8 + len);\n  packet.writeInt32LE(op, 0);\n  packet.writeInt32LE(len, 4);\n  packet.write(data, 8, len);\n  return packet;\n}\n\nconst working = {\n  full: '',\n  op: undefined,\n};\n\nfunction decode(socket, callback) {\n  const packet = socket.read();\n  if (!packet) {\n    return;\n  }\n\n  let { op } = working;\n  let raw;\n  if (working.full === '') {\n    op = working.op = packet.readInt32LE(0);\n    const len = packet.readInt32LE(4);\n    raw = packet.slice(8, len + 8);\n  } else {\n    raw = packet.toString();\n  }\n\n  try {\n    const data = JSON.parse(working.full + raw);\n    callback({ op, data }); // eslint-disable-line callback-return\n    working.full = '';\n    working.op = undefined;\n  } catch (err) {\n    working.full += raw;\n  }\n\n  decode(socket, callback);\n}\n\nclass IPCTransport extends EventEmitter {\n  constructor(client) {\n    super();\n    this.client = client;\n    this.socket = null;\n  }\n\n  async connect() {\n    const socket = this.socket = await getIPC();\n    socket.on('close', this.onClose.bind(this));\n    socket.on('error', this.onClose.bind(this));\n    this.emit('open');\n    socket.write(encode(OPCodes.HANDSHAKE, {\n      v: 1,\n      client_id: this.client.clientId,\n    }));\n    socket.pause();\n    socket.on('readable', () => {\n      decode(socket, ({ op, data }) => {\n        switch (op) {\n          case OPCodes.PING:\n            this.send(data, OPCodes.PONG);\n            break;\n          case OPCodes.FRAME:\n            if (!data) {\n              return;\n            }\n            if (data.cmd === 'AUTHORIZE' && data.evt !== 'ERROR') {\n              findEndpoint()\n                .then((endpoint) => {\n                  this.client.request.endpoint = endpoint;\n                })\n                .catch((e) => {\n                  this.client.emit('error', e);\n                });\n            }\n            this.emit('message', data);\n            break;\n          case OPCodes.CLOSE:\n            this.emit('close', data);\n            break;\n          default:\n            break;\n        }\n      });\n    });\n  }\n\n  onClose(e) {\n    this.emit('close', e);\n  }\n\n  send(data, op = OPCodes.FRAME) {\n    this.socket.write(encode(op, data));\n  }\n\n  async close() {\n    return new Promise((r) => {\n      this.once('close', r);\n      this.send({}, OPCodes.CLOSE);\n      this.socket.end();\n    });\n  }\n\n  ping() {\n    this.send(uuid(), OPCodes.PING);\n  }\n}\n\nmodule.exports = IPCTransport;\nmodule.exports.encode = encode;\nmodule.exports.decode = decode;\n","'use strict';\n\nfunction keyMirror(arr) {\n  const tmp = {};\n  for (const value of arr) {\n    tmp[value] = value;\n  }\n  return tmp;\n}\n\n\nexports.browser = typeof window !== 'undefined';\n\nexports.RPCCommands = keyMirror([\n  'DISPATCH',\n  'AUTHORIZE',\n  'AUTHENTICATE',\n  'GET_GUILD',\n  'GET_GUILDS',\n  'GET_CHANNEL',\n  'GET_CHANNELS',\n  'CREATE_CHANNEL_INVITE',\n  'GET_RELATIONSHIPS',\n  'GET_USER',\n  'SUBSCRIBE',\n  'UNSUBSCRIBE',\n  'SET_USER_VOICE_SETTINGS',\n  'SET_USER_VOICE_SETTINGS_2',\n  'SELECT_VOICE_CHANNEL',\n  'GET_SELECTED_VOICE_CHANNEL',\n  'SELECT_TEXT_CHANNEL',\n  'GET_VOICE_SETTINGS',\n  'SET_VOICE_SETTINGS_2',\n  'SET_VOICE_SETTINGS',\n  'CAPTURE_SHORTCUT',\n  'SET_ACTIVITY',\n  'SEND_ACTIVITY_JOIN_INVITE',\n  'CLOSE_ACTIVITY_JOIN_REQUEST',\n  'ACTIVITY_INVITE_USER',\n  'ACCEPT_ACTIVITY_INVITE',\n  'INVITE_BROWSER',\n  'DEEP_LINK',\n  'CONNECTIONS_CALLBACK',\n  'BRAINTREE_POPUP_BRIDGE_CALLBACK',\n  'GIFT_CODE_BROWSER',\n  'GUILD_TEMPLATE_BROWSER',\n  'OVERLAY',\n  'BROWSER_HANDOFF',\n  'SET_CERTIFIED_DEVICES',\n  'GET_IMAGE',\n  'CREATE_LOBBY',\n  'UPDATE_LOBBY',\n  'DELETE_LOBBY',\n  'UPDATE_LOBBY_MEMBER',\n  'CONNECT_TO_LOBBY',\n  'DISCONNECT_FROM_LOBBY',\n  'SEND_TO_LOBBY',\n  'SEARCH_LOBBIES',\n  'CONNECT_TO_LOBBY_VOICE',\n  'DISCONNECT_FROM_LOBBY_VOICE',\n  'SET_OVERLAY_LOCKED',\n  'OPEN_OVERLAY_ACTIVITY_INVITE',\n  'OPEN_OVERLAY_GUILD_INVITE',\n  'OPEN_OVERLAY_VOICE_SETTINGS',\n  'VALIDATE_APPLICATION',\n  'GET_ENTITLEMENT_TICKET',\n  'GET_APPLICATION_TICKET',\n  'START_PURCHASE',\n  'GET_SKUS',\n  'GET_ENTITLEMENTS',\n  'GET_NETWORKING_CONFIG',\n  'NETWORKING_SYSTEM_METRICS',\n  'NETWORKING_PEER_METRICS',\n  'NETWORKING_CREATE_TOKEN',\n  'SET_USER_ACHIEVEMENT',\n  'GET_USER_ACHIEVEMENTS',\n]);\n\nexports.RPCEvents = keyMirror([\n  'CURRENT_USER_UPDATE',\n  'GUILD_STATUS',\n  'GUILD_CREATE',\n  'CHANNEL_CREATE',\n  'RELATIONSHIP_UPDATE',\n  'VOICE_CHANNEL_SELECT',\n  'VOICE_STATE_CREATE',\n  'VOICE_STATE_DELETE',\n  'VOICE_STATE_UPDATE',\n  'VOICE_SETTINGS_UPDATE',\n  'VOICE_SETTINGS_UPDATE_2',\n  'VOICE_CONNECTION_STATUS',\n  'SPEAKING_START',\n  'SPEAKING_STOP',\n  'GAME_JOIN',\n  'GAME_SPECTATE',\n  'ACTIVITY_JOIN',\n  'ACTIVITY_JOIN_REQUEST',\n  'ACTIVITY_SPECTATE',\n  'ACTIVITY_INVITE',\n  'NOTIFICATION_CREATE',\n  'MESSAGE_CREATE',\n  'MESSAGE_UPDATE',\n  'MESSAGE_DELETE',\n  'LOBBY_DELETE',\n  'LOBBY_UPDATE',\n  'LOBBY_MEMBER_CONNECT',\n  'LOBBY_MEMBER_DISCONNECT',\n  'LOBBY_MEMBER_UPDATE',\n  'LOBBY_MESSAGE',\n  'CAPTURE_SHORTCUT_CHANGE',\n  'OVERLAY',\n  'OVERLAY_UPDATE',\n  'ENTITLEMENT_CREATE',\n  'ENTITLEMENT_DELETE',\n  'USER_ACHIEVEMENT_UPDATE',\n  'READY',\n  'ERROR',\n]);\n\nexports.RPCErrors = {\n  CAPTURE_SHORTCUT_ALREADY_LISTENING: 5004,\n  GET_GUILD_TIMED_OUT: 5002,\n  INVALID_ACTIVITY_JOIN_REQUEST: 4012,\n  INVALID_ACTIVITY_SECRET: 5005,\n  INVALID_CHANNEL: 4005,\n  INVALID_CLIENTID: 4007,\n  INVALID_COMMAND: 4002,\n  INVALID_ENTITLEMENT: 4015,\n  INVALID_EVENT: 4004,\n  INVALID_GIFT_CODE: 4016,\n  INVALID_GUILD: 4003,\n  INVALID_INVITE: 4011,\n  INVALID_LOBBY: 4013,\n  INVALID_LOBBY_SECRET: 4014,\n  INVALID_ORIGIN: 4008,\n  INVALID_PAYLOAD: 4000,\n  INVALID_PERMISSIONS: 4006,\n  INVALID_TOKEN: 4009,\n  INVALID_USER: 4010,\n  LOBBY_FULL: 5007,\n  NO_ELIGIBLE_ACTIVITY: 5006,\n  OAUTH2_ERROR: 5000,\n  PURCHASE_CANCELED: 5008,\n  PURCHASE_ERROR: 5009,\n  RATE_LIMITED: 5011,\n  SELECT_CHANNEL_TIMED_OUT: 5001,\n  SELECT_VOICE_FORCE_REQUIRED: 5003,\n  SERVICE_UNAVAILABLE: 1001,\n  TRANSACTION_ABORTED: 1002,\n  UNAUTHORIZED_FOR_ACHIEVEMENT: 5010,\n  UNKNOWN_ERROR: 1000,\n};\n\nexports.RPCCloseCodes = {\n  CLOSE_NORMAL: 1000,\n  CLOSE_UNSUPPORTED: 1003,\n  CLOSE_ABNORMAL: 1006,\n  INVALID_CLIENTID: 4000,\n  INVALID_ORIGIN: 4001,\n  RATELIMITED: 4002,\n  TOKEN_REVOKED: 4003,\n  INVALID_VERSION: 4004,\n  INVALID_ENCODING: 4005,\n};\n\nexports.LobbyTypes = {\n  PRIVATE: 1,\n  PUBLIC: 2,\n};\n\nexports.RelationshipTypes = {\n  NONE: 0,\n  FRIEND: 1,\n  BLOCKED: 2,\n  PENDING_INCOMING: 3,\n  PENDING_OUTGOING: 4,\n  IMPLICIT: 5,\n};\n","'use strict';\n\nconst EventEmitter = require('events');\nconst { browser } = require('../constants');\n\n// eslint-disable-next-line\nconst WebSocket = browser ? window.WebSocket : require('ws');\n\nconst pack = (d) => JSON.stringify(d);\nconst unpack = (s) => JSON.parse(s);\n\nclass WebSocketTransport extends EventEmitter {\n  constructor(client) {\n    super();\n    this.client = client;\n    this.ws = null;\n    this.tries = 0;\n  }\n\n  async connect() {\n    const port = 6463 + (this.tries % 10);\n    this.tries += 1;\n\n    this.ws = new WebSocket(\n      `ws://127.0.0.1:${port}/?v=1&client_id=${this.client.clientId}`,\n      browser ? undefined : { origin: this.client.options.origin },\n    );\n    this.ws.onopen = this.onOpen.bind(this);\n    this.ws.onclose = this.onClose.bind(this);\n    this.ws.onerror = this.onError.bind(this);\n    this.ws.onmessage = this.onMessage.bind(this);\n  }\n\n  onOpen() {\n    this.emit('open');\n  }\n\n  onClose(event) {\n    if (!event.wasClean) {\n      return;\n    }\n    this.emit('close', event);\n  }\n\n  onError(event) {\n    try {\n      this.ws.close();\n    } catch {} // eslint-disable-line no-empty\n\n    if (this.tries > 20) {\n      this.emit('error', event.error);\n    } else {\n      setTimeout(() => {\n        this.connect();\n      }, 250);\n    }\n  }\n\n  onMessage(event) {\n    this.emit('message', unpack(event.data));\n  }\n\n  send(data) {\n    this.ws.send(pack(data));\n  }\n\n  ping() {} // eslint-disable-line no-empty-function\n\n  close() {\n    return new Promise((r) => {\n      this.once('close', r);\n      this.ws.close();\n    });\n  }\n}\n\nmodule.exports = WebSocketTransport;\n","'use strict';\n\nmodule.exports = {\n  ipc: require('./ipc'),\n  websocket: require('./websocket'),\n};\n","'use strict';\n\nconst EventEmitter = require('events');\nconst { setTimeout, clearTimeout } = require('timers');\nconst fetch = require('node-fetch');\nconst transports = require('./transports');\nconst { RPCCommands, RPCEvents, RelationshipTypes } = require('./constants');\nconst { pid: getPid, uuid } = require('./util');\n\nfunction subKey(event, args) {\n  return `${event}${JSON.stringify(args)}`;\n}\n\n/**\n * @typedef {RPCClientOptions}\n * @extends {ClientOptions}\n * @prop {string} transport RPC transport. one of `ipc` or `websocket`\n */\n\n/**\n * The main hub for interacting with Discord RPC\n * @extends {BaseClient}\n */\nclass RPCClient extends EventEmitter {\n  /**\n   * @param {RPCClientOptions} [options] Options for the client.\n   * You must provide a transport\n   */\n  constructor(options = {}) {\n    super();\n\n    this.options = options;\n\n    this.accessToken = null;\n    this.clientId = null;\n\n    /**\n     * Application used in this client\n     * @type {?ClientApplication}\n     */\n    this.application = null;\n\n    /**\n     * User used in this application\n     * @type {?User}\n     */\n    this.user = null;\n\n    const Transport = transports[options.transport];\n    if (!Transport) {\n      throw new TypeError('RPC_INVALID_TRANSPORT', options.transport);\n    }\n\n    this.fetch = (method, path, { data, query } = {}) =>\n      fetch(`${this.fetch.endpoint}${path}${query ? new URLSearchParams(query) : ''}`, {\n        method,\n        body: data,\n        headers: {\n          Authorization: `Bearer ${this.accessToken}`,\n        },\n      }).then(async (r) => {\n        const body = await r.json();\n        if (!r.ok) {\n          const e = new Error(r.status);\n          e.body = body;\n          throw e;\n        }\n        return body;\n      });\n\n    this.fetch.endpoint = 'https://discord.com/api';\n\n    /**\n     * Raw transport userd\n     * @type {RPCTransport}\n     * @private\n     */\n    this.transport = new Transport(this);\n    this.transport.on('message', this._onRpcMessage.bind(this));\n\n    /**\n     * Map of nonces being expected from the transport\n     * @type {Map}\n     * @private\n     */\n    this._expecting = new Map();\n\n    /**\n     * Map of current subscriptions\n     * @type {Map}\n     * @private\n     */\n    this._subscriptions = new Map();\n\n    this._connectPromise = undefined;\n  }\n\n  /**\n   * Search and connect to RPC\n   */\n  connect(clientId) {\n    if (this._connectPromise) {\n      return this._connectPromise;\n    }\n    this._connectPromise = new Promise((resolve, reject) => {\n      this.clientId = clientId;\n      const timeout = setTimeout(() => reject(new Error('RPC_CONNECTION_TIMEOUT')), 10e3);\n      timeout.unref();\n      this.once('connected', () => {\n        clearTimeout(timeout);\n        resolve(this);\n      });\n      this.transport.once('close', () => {\n        this._expecting.forEach((e) => {\n          e.reject(new Error('connection closed'));\n        });\n        this.emit('disconnected');\n        reject(new Error('connection closed'));\n      });\n      this.transport.connect().catch(reject);\n    });\n    return this._connectPromise;\n  }\n\n  /**\n   * @typedef {RPCLoginOptions}\n   * @param {string} clientId Client ID\n   * @param {string} [clientSecret] Client secret\n   * @param {string} [accessToken] Access token\n   * @param {string} [rpcToken] RPC token\n   * @param {string} [tokenEndpoint] Token endpoint\n   * @param {string[]} [scopes] Scopes to authorize with\n   */\n\n  /**\n   * Performs authentication flow. Automatically calls Client#connect if needed.\n   * @param {RPCLoginOptions} options Options for authentication.\n   * At least one property must be provided to perform login.\n   * @example client.login({ clientId: '1234567', clientSecret: 'abcdef123' });\n   * @returns {Promise<RPCClient>}\n   */\n  async login(options = {}) {\n    let { clientId, accessToken } = options;\n    await this.connect(clientId);\n    if (!options.scopes) {\n      this.emit('ready');\n      return this;\n    }\n    if (!accessToken) {\n      accessToken = await this.authorize(options);\n    }\n    return this.authenticate(accessToken);\n  }\n\n  /**\n   * Request\n   * @param {string} cmd Command\n   * @param {Object} [args={}] Arguments\n   * @param {string} [evt] Event\n   * @returns {Promise}\n   * @private\n   */\n  request(cmd, args, evt) {\n    return new Promise((resolve, reject) => {\n      const nonce = uuid();\n      this.transport.send({ cmd, args, evt, nonce });\n      this._expecting.set(nonce, { resolve, reject });\n    });\n  }\n\n  /**\n   * Message handler\n   * @param {Object} message message\n   * @private\n   */\n  _onRpcMessage(message) {\n    if (message.cmd === RPCCommands.DISPATCH && message.evt === RPCEvents.READY) {\n      if (message.data.user) {\n        this.user = message.data.user;\n      }\n      this.emit('connected');\n    } else if (this._expecting.has(message.nonce)) {\n      const { resolve, reject } = this._expecting.get(message.nonce);\n      if (message.evt === 'ERROR') {\n        const e = new Error(message.data.message);\n        e.code = message.data.code;\n        e.data = message.data;\n        reject(e);\n      } else {\n        resolve(message.data);\n      }\n      this._expecting.delete(message.nonce);\n    } else {\n      const subid = subKey(message.evt, message.args);\n      if (!this._subscriptions.has(subid)) {\n        return;\n      }\n      this._subscriptions.get(subid)(message.data);\n    }\n  }\n\n  /**\n   * Authorize\n   * @param {Object} options options\n   * @returns {Promise}\n   * @private\n   */\n  async authorize({ scopes, clientSecret, rpcToken, redirectUri } = {}) {\n    if (clientSecret && rpcToken === true) {\n      const body = await this.fetch('POST', '/oauth2/token/rpc', {\n        data: new URLSearchParams({\n          client_id: this.clientId,\n          client_secret: clientSecret,\n        }),\n      });\n      rpcToken = body.rpc_token;\n    }\n\n    const { code } = await this.request('AUTHORIZE', {\n      scopes,\n      client_id: this.clientId,\n      rpc_token: rpcToken,\n    });\n\n    const response = await this.fetch('POST', '/oauth2/token', {\n      data: new URLSearchParams({\n        client_id: this.clientId,\n        client_secret: clientSecret,\n        code,\n        grant_type: 'authorization_code',\n        redirect_uri: redirectUri,\n      }),\n    });\n\n    return response.access_token;\n  }\n\n  /**\n   * Authenticate\n   * @param {string} accessToken access token\n   * @returns {Promise}\n   * @private\n   */\n  authenticate(accessToken) {\n    return this.request('AUTHENTICATE', { access_token: accessToken })\n      .then(({ application, user }) => {\n        this.accessToken = accessToken;\n        this.application = application;\n        this.user = user;\n        this.emit('ready');\n        return this;\n      });\n  }\n\n\n  /**\n   * Fetch a guild\n   * @param {Snowflake} id Guild ID\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Guild>}\n   */\n  getGuild(id, timeout) {\n    return this.request(RPCCommands.GET_GUILD, { guild_id: id, timeout });\n  }\n\n  /**\n   * Fetch all guilds\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Collection<Snowflake, Guild>>}\n   */\n  getGuilds(timeout) {\n    return this.request(RPCCommands.GET_GUILDS, { timeout });\n  }\n\n  /**\n   * Get a channel\n   * @param {Snowflake} id Channel ID\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Channel>}\n   */\n  getChannel(id, timeout) {\n    return this.request(RPCCommands.GET_CHANNEL, { channel_id: id, timeout });\n  }\n\n  /**\n   * Get all channels\n   * @param {Snowflake} [id] Guild ID\n   * @param {number} [timeout] Timeout request\n   * @returns {Promise<Collection<Snowflake, Channel>>}\n   */\n  async getChannels(id, timeout) {\n    const { channels } = await this.request(RPCCommands.GET_CHANNELS, {\n      timeout,\n      guild_id: id,\n    });\n    return channels;\n  }\n\n  /**\n   * @typedef {CertifiedDevice}\n   * @prop {string} type One of `AUDIO_INPUT`, `AUDIO_OUTPUT`, `VIDEO_INPUT`\n   * @prop {string} uuid This device's Windows UUID\n   * @prop {object} vendor Vendor information\n   * @prop {string} vendor.name Vendor's name\n   * @prop {string} vendor.url Vendor's url\n   * @prop {object} model Model information\n   * @prop {string} model.name Model's name\n   * @prop {string} model.url Model's url\n   * @prop {string[]} related Array of related product's Windows UUIDs\n   * @prop {boolean} echoCancellation If the device has echo cancellation\n   * @prop {boolean} noiseSuppression If the device has noise suppression\n   * @prop {boolean} automaticGainControl If the device has automatic gain control\n   * @prop {boolean} hardwareMute If the device has a hardware mute\n   */\n\n  /**\n   * Tell discord which devices are certified\n   * @param {CertifiedDevice[]} devices Certified devices to send to discord\n   * @returns {Promise}\n   */\n  setCertifiedDevices(devices) {\n    return this.request(RPCCommands.SET_CERTIFIED_DEVICES, {\n      devices: devices.map((d) => ({\n        type: d.type,\n        id: d.uuid,\n        vendor: d.vendor,\n        model: d.model,\n        related: d.related,\n        echo_cancellation: d.echoCancellation,\n        noise_suppression: d.noiseSuppression,\n        automatic_gain_control: d.automaticGainControl,\n        hardware_mute: d.hardwareMute,\n      })),\n    });\n  }\n\n  /**\n   * @typedef {UserVoiceSettings}\n   * @prop {Snowflake} id ID of the user these settings apply to\n   * @prop {?Object} [pan] Pan settings, an object with `left` and `right` set between\n   * 0.0 and 1.0, inclusive\n   * @prop {?number} [volume=100] The volume\n   * @prop {bool} [mute] If the user is muted\n   */\n\n  /**\n   * Set the voice settings for a user, by id\n   * @param {Snowflake} id ID of the user to set\n   * @param {UserVoiceSettings} settings Settings\n   * @returns {Promise}\n   */\n  setUserVoiceSettings(id, settings) {\n    return this.request(RPCCommands.SET_USER_VOICE_SETTINGS, {\n      user_id: id,\n      pan: settings.pan,\n      mute: settings.mute,\n      volume: settings.volume,\n    });\n  }\n\n  /**\n   * Move the user to a voice channel\n   * @param {Snowflake} id ID of the voice channel\n   * @param {Object} [options] Options\n   * @param {number} [options.timeout] Timeout for the command\n   * @param {boolean} [options.force] Force this move. This should only be done if you\n   * have explicit permission from the user.\n   * @returns {Promise}\n   */\n  selectVoiceChannel(id, { timeout, force = false } = {}) {\n    return this.request(RPCCommands.SELECT_VOICE_CHANNEL, { channel_id: id, timeout, force });\n  }\n\n  /**\n   * Move the user to a text channel\n   * @param {Snowflake} id ID of the voice channel\n   * @param {Object} [options] Options\n   * @param {number} [options.timeout] Timeout for the command\n   * have explicit permission from the user.\n   * @returns {Promise}\n   */\n  selectTextChannel(id, { timeout } = {}) {\n    return this.request(RPCCommands.SELECT_TEXT_CHANNEL, { channel_id: id, timeout });\n  }\n\n  /**\n   * Get current voice settings\n   * @returns {Promise}\n   */\n  getVoiceSettings() {\n    return this.request(RPCCommands.GET_VOICE_SETTINGS)\n      .then((s) => ({\n        automaticGainControl: s.automatic_gain_control,\n        echoCancellation: s.echo_cancellation,\n        noiseSuppression: s.noise_suppression,\n        qos: s.qos,\n        silenceWarning: s.silence_warning,\n        deaf: s.deaf,\n        mute: s.mute,\n        input: {\n          availableDevices: s.input.available_devices,\n          device: s.input.device_id,\n          volume: s.input.volume,\n        },\n        output: {\n          availableDevices: s.output.available_devices,\n          device: s.output.device_id,\n          volume: s.output.volume,\n        },\n        mode: {\n          type: s.mode.type,\n          autoThreshold: s.mode.auto_threshold,\n          threshold: s.mode.threshold,\n          shortcut: s.mode.shortcut,\n          delay: s.mode.delay,\n        },\n      }));\n  }\n\n  /**\n   * Set current voice settings, overriding the current settings until this session disconnects.\n   * This also locks the settings for any other rpc sessions which may be connected.\n   * @param {Object} args Settings\n   * @returns {Promise}\n   */\n  setVoiceSettings(args) {\n    return this.request(RPCCommands.SET_VOICE_SETTINGS, {\n      automatic_gain_control: args.automaticGainControl,\n      echo_cancellation: args.echoCancellation,\n      noise_suppression: args.noiseSuppression,\n      qos: args.qos,\n      silence_warning: args.silenceWarning,\n      deaf: args.deaf,\n      mute: args.mute,\n      input: args.input ? {\n        device_id: args.input.device,\n        volume: args.input.volume,\n      } : undefined,\n      output: args.output ? {\n        device_id: args.output.device,\n        volume: args.output.volume,\n      } : undefined,\n      mode: args.mode ? {\n        mode: args.mode.type,\n        auto_threshold: args.mode.autoThreshold,\n        threshold: args.mode.threshold,\n        shortcut: args.mode.shortcut,\n        delay: args.mode.delay,\n      } : undefined,\n    });\n  }\n\n  /**\n   * Capture a shortcut using the client\n   * The callback takes (key, stop) where `stop` is a function that will stop capturing.\n   * This `stop` function must be called before disconnecting or else the user will have\n   * to restart their client.\n   * @param {Function} callback Callback handling keys\n   * @returns {Promise<Function>}\n   */\n  captureShortcut(callback) {\n    const subid = subKey(RPCEvents.CAPTURE_SHORTCUT_CHANGE);\n    const stop = () => {\n      this._subscriptions.delete(subid);\n      return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'STOP' });\n    };\n    this._subscriptions.set(subid, ({ shortcut }) => {\n      callback(shortcut, stop);\n    });\n    return this.request(RPCCommands.CAPTURE_SHORTCUT, { action: 'START' })\n      .then(() => stop);\n  }\n\n  /**\n   * Sets the presence for the logged in user.\n   * @param {object} args The rich presence to pass.\n   * @param {number} [pid] The application's process ID. Defaults to the executing process' PID.\n   * @returns {Promise}\n   */\n  setActivity(args = {}, pid = getPid()) {\n    let timestamps;\n    let assets;\n    let party;\n    let secrets;\n    if (args.startTimestamp || args.endTimestamp) {\n      timestamps = {\n        start: args.startTimestamp,\n        end: args.endTimestamp,\n      };\n      if (timestamps.start instanceof Date) {\n        timestamps.start = Math.round(timestamps.start.getTime());\n      }\n      if (timestamps.end instanceof Date) {\n        timestamps.end = Math.round(timestamps.end.getTime());\n      }\n      if (timestamps.start > 2147483647000) {\n        throw new RangeError('timestamps.start must fit into a unix timestamp');\n      }\n      if (timestamps.end > 2147483647000) {\n        throw new RangeError('timestamps.end must fit into a unix timestamp');\n      }\n    }\n    if (\n      args.largeImageKey || args.largeImageText\n      || args.smallImageKey || args.smallImageText\n    ) {\n      assets = {\n        large_image: args.largeImageKey,\n        large_text: args.largeImageText,\n        small_image: args.smallImageKey,\n        small_text: args.smallImageText,\n      };\n    }\n    if (args.partySize || args.partyId || args.partyMax) {\n      party = { id: args.partyId };\n      if (args.partySize || args.partyMax) {\n        party.size = [args.partySize, args.partyMax];\n      }\n    }\n    if (args.matchSecret || args.joinSecret || args.spectateSecret) {\n      secrets = {\n        match: args.matchSecret,\n        join: args.joinSecret,\n        spectate: args.spectateSecret,\n      };\n    }\n\n    return this.request(RPCCommands.SET_ACTIVITY, {\n      pid,\n      activity: {\n        state: args.state,\n        details: args.details,\n        timestamps,\n        assets,\n        party,\n        secrets,\n        buttons: args.buttons,\n        instance: !!args.instance,\n      },\n    });\n  }\n\n  /**\n   * Clears the currently set presence, if any. This will hide the \"Playing X\" message\n   * displayed below the user's name.\n   * @param {number} [pid] The application's process ID. Defaults to the executing process' PID.\n   * @returns {Promise}\n   */\n  clearActivity(pid = getPid()) {\n    return this.request(RPCCommands.SET_ACTIVITY, {\n      pid,\n    });\n  }\n\n  /**\n   * Invite a user to join the game the RPC user is currently playing\n   * @param {User} user The user to invite\n   * @returns {Promise}\n   */\n  sendJoinInvite(user) {\n    return this.request(RPCCommands.SEND_ACTIVITY_JOIN_INVITE, {\n      user_id: user.id || user,\n    });\n  }\n\n  /**\n   * Request to join the game the user is playing\n   * @param {User} user The user whose game you want to request to join\n   * @returns {Promise}\n   */\n  sendJoinRequest(user) {\n    return this.request(RPCCommands.SEND_ACTIVITY_JOIN_REQUEST, {\n      user_id: user.id || user,\n    });\n  }\n\n  /**\n   * Reject a join request from a user\n   * @param {User} user The user whose request you wish to reject\n   * @returns {Promise}\n   */\n  closeJoinRequest(user) {\n    return this.request(RPCCommands.CLOSE_ACTIVITY_JOIN_REQUEST, {\n      user_id: user.id || user,\n    });\n  }\n\n  createLobby(type, capacity, metadata) {\n    return this.request(RPCCommands.CREATE_LOBBY, {\n      type,\n      capacity,\n      metadata,\n    });\n  }\n\n  updateLobby(lobby, { type, owner, capacity, metadata } = {}) {\n    return this.request(RPCCommands.UPDATE_LOBBY, {\n      id: lobby.id || lobby,\n      type,\n      owner_id: (owner && owner.id) || owner,\n      capacity,\n      metadata,\n    });\n  }\n\n  deleteLobby(lobby) {\n    return this.request(RPCCommands.DELETE_LOBBY, {\n      id: lobby.id || lobby,\n    });\n  }\n\n  connectToLobby(id, secret) {\n    return this.request(RPCCommands.CONNECT_TO_LOBBY, {\n      id,\n      secret,\n    });\n  }\n\n  sendToLobby(lobby, data) {\n    return this.request(RPCCommands.SEND_TO_LOBBY, {\n      id: lobby.id || lobby,\n      data,\n    });\n  }\n\n  disconnectFromLobby(lobby) {\n    return this.request(RPCCommands.DISCONNECT_FROM_LOBBY, {\n      id: lobby.id || lobby,\n    });\n  }\n\n  updateLobbyMember(lobby, user, metadata) {\n    return this.request(RPCCommands.UPDATE_LOBBY_MEMBER, {\n      lobby_id: lobby.id || lobby,\n      user_id: user.id || user,\n      metadata,\n    });\n  }\n\n  getRelationships() {\n    const types = Object.keys(RelationshipTypes);\n    return this.request(RPCCommands.GET_RELATIONSHIPS)\n      .then((o) => o.relationships.map((r) => ({\n        ...r,\n        type: types[r.type],\n      })));\n  }\n\n  /**\n   * Subscribe to an event\n   * @param {string} event Name of event e.g. `MESSAGE_CREATE`\n   * @param {Object} [args] Args for event e.g. `{ channel_id: '1234' }`\n   * @param {Function} callback Callback when an event for the subscription is triggered\n   * @returns {Promise<Object>}\n   */\n  subscribe(event, args, callback) {\n    if (!callback && typeof args === 'function') {\n      callback = args;\n      args = undefined;\n    }\n    return this.request(RPCCommands.SUBSCRIBE, args, event).then(() => {\n      const subid = subKey(event, args);\n      this._subscriptions.set(subid, callback);\n      return {\n        unsubscribe: () => this.request(RPCCommands.UNSUBSCRIBE, args, event)\n          .then(() => this._subscriptions.delete(subid)),\n      };\n    });\n  }\n\n  /**\n   * Destroy the client\n   */\n  async destroy() {\n    await this.transport.close();\n  }\n}\n\nmodule.exports = RPCClient;\n","'use strict';\n\nconst util = require('./util');\n\nmodule.exports = {\n  Client: require('./client'),\n  register(id) {\n    return util.register(`discord-${id}`);\n  },\n};\n","import { Notice } from \"obsidian\";\nimport ObsidianDiscordRPC from \"./main\";\n\nexport class Logger {\n  plugin: ObsidianDiscordRPC = (this as any).plugin;\n\n  log(message: string, showPopups: boolean): void {\n    if (showPopups) {\n      new Notice(message);\n    }\n\n    console.log(`discordrpc: ${message}`);\n  }\n\n  logIgnoreNoNotice(message: string): void {\n    new Notice(message);\n    console.log(`discordrpc: ${message}`);\n  }\n}\n","export class DiscordRPCSettings {\n  showVaultName: boolean = true;\n  showCurrentFileName: boolean = true;\n  showPopups: boolean = true;\n  customVaultName: string = \"\";\n  showFileExtension: boolean = false;\n  useLoadedTime: boolean = false;\n  connectOnStart: boolean = true;\n  autoHideStatusBar: boolean = true;\n}\n\nexport enum PluginState {\n  connected,\n  connecting,\n  disconnected,\n}\n","import { PluginSettingTab, Setting, TFile } from \"obsidian\";\nimport { Logger } from \"src/logger\";\nimport ObsidianDiscordRPC from \"src/main\";\n\nexport class DiscordRPCSettingsTab extends PluginSettingTab {\n  public logger: Logger = new Logger();\n\n  display(): void {\n    let { containerEl } = this;\n    const plugin: ObsidianDiscordRPC = (this as any).plugin;\n\n    containerEl.empty();\n    containerEl.createEl(\"h2\", { text: \"Discord Rich Presence Settings\" });\n\n    containerEl.createEl(\"h3\", { text: \"Vault Name Settings\" });\n    new Setting(containerEl)\n      .setName(\"Show Vault Name\")\n      .setDesc(\n        \"Enable this to show the name of the vault you are working with.\"\n      )\n      .addToggle((boolean) =>\n        boolean.setValue(plugin.settings.showVaultName).onChange((value) => {\n          plugin.settings.showVaultName = value;\n          plugin.saveData(plugin.settings);\n\n          if (boolean.getValue()) {\n            this.logger.logIgnoreNoNotice(\"Vault Name is now Visable\");\n          } else {\n            this.logger.logIgnoreNoNotice(\"Vault Name is no longer Visable\");\n          }\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Set Custom Vault Name\")\n      .setDesc(\n        \"Change the vault name shown publicly. Leave blank to use your actual vault name.\"\n      )\n      .addText((text) =>\n        text.setValue(plugin.settings.customVaultName).onChange((value) => {\n          plugin.settings.customVaultName = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        })\n      );\n\n    containerEl.createEl(\"h3\", { text: \"File Name Settings\" });\n    new Setting(containerEl)\n      .setName(\"Show Current File Name\")\n      .setDesc(\"Enable this to show the name of the file you are working on.\")\n      .addToggle((boolean) =>\n        boolean\n          .setValue(plugin.settings.showCurrentFileName)\n          .onChange((value) => {\n            plugin.settings.showCurrentFileName = value;\n            plugin.saveData(plugin.settings);\n\n            if (boolean.getValue()) {\n              this.logger.logIgnoreNoNotice(\"File Name is now Visable\");\n            } else {\n              this.logger.logIgnoreNoNotice(\"File Name is no longer Visable\");\n            }\n\n            plugin.setActivity(\n              this.app.vault.getName(),\n              plugin.currentFile.basename,\n              plugin.currentFile.extension\n            );\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Show File Extension\")\n      .setDesc(\"Enable this to show file extension.\")\n      .addToggle((boolean) =>\n        boolean\n          .setValue(plugin.settings.showFileExtension)\n          .onChange((value) => {\n            plugin.settings.showFileExtension = value;\n            plugin.saveData(plugin.settings);\n\n            plugin.setActivity(\n              this.app.vault.getName(),\n              plugin.currentFile.basename,\n              plugin.currentFile.extension\n            );\n          })\n      );\n\n    containerEl.createEl(\"h3\", { text: \"Time Settings\" });\n    new Setting(containerEl)\n      .setName(\"Use Obsidian Total Time\")\n      .setDesc(\n        \"Enable to use the total time you have been using Obsidian, instead of the time spent editing a single file.\"\n      )\n      .addToggle((boolean) => {\n        boolean.setValue(plugin.settings.useLoadedTime).onChange((value) => {\n          plugin.settings.useLoadedTime = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        });\n      });\n\n    containerEl.createEl(\"h3\", { text: \"Status Bar Settings\" });\n    new Setting(containerEl)\n      .setName(\"Automatically hide Status Bar\")\n      .setDesc(\n        \"Automatically hide status bar after successfully connecting to Discord.\"\n      )\n      .addToggle((boolean) => {\n        boolean.setValue(plugin.settings.autoHideStatusBar).onChange((value) => {\n          plugin.settings.autoHideStatusBar = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        });\n      });\n\n    containerEl.createEl(\"h3\", { text: \"Startup Settings\" });\n    new Setting(containerEl)\n      .setName(\"Automatically Connect to Discord\")\n      .setDesc(\n        \"Automatically connect to Discord on startup. You can always click the status bar to manually connect.\"\n      )\n      .addToggle((boolean) => {\n        boolean.setValue(plugin.settings.connectOnStart).onChange((value) => {\n          plugin.settings.connectOnStart = value;\n          plugin.saveData(plugin.settings);\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        });\n      });\n\n    containerEl.createEl(\"h3\", { text: \"Notice Settings\" });\n    new Setting(containerEl)\n      .setName(\"Show Notices\")\n      .setDesc(\"Enable this to show connection Notices.\")\n      .addToggle((boolean) =>\n        boolean.setValue(plugin.settings.showPopups).onChange((value) => {\n          plugin.settings.showPopups = value;\n          plugin.saveData(plugin.settings);\n\n          if (boolean.getValue()) {\n            this.logger.logIgnoreNoNotice(\"Notices Enabled\");\n          } else {\n            this.logger.logIgnoreNoNotice(\"Notices Disabled\");\n          }\n\n          plugin.setActivity(\n            this.app.vault.getName(),\n            plugin.currentFile.basename,\n            plugin.currentFile.extension\n          );\n        })\n      );\n  }\n}\n","import { PluginState } from \"./settings/settings\";\n\nexport class StatusBar {\n  private statusBarEl: HTMLElement;\n\n  constructor(statusBarEl: HTMLElement) {\n    this.statusBarEl = statusBarEl;\n  }\n\n  displayState(state: PluginState, autoHide: boolean) {\n    switch (state) {\n      case PluginState.connected:\n        this.displayConnected(autoHide ? 10000 : 0);\n        break;\n      case PluginState.connecting:\n        this.statusBarEl.setText(`Connecting to Discord...`);\n        break;\n      case PluginState.disconnected:\n        this.statusBarEl.setText(`\\u{1F5D8} Reconnect to Discord`);\n        break;\n    }\n  }\n\n  displayConnected(timeout: number) {\n    this.statusBarEl.setText(`\\u{1F30D} Connected to Discord`);\n\n    if (timeout && timeout > 0) {\n      window.setTimeout(() => {\n        this.statusBarEl.setText(\"\");\n      }, timeout);\n    } else {\n      window.setTimeout(() => {\n        this.statusBarEl.setText(`\\u{1F30D}`);\n      }, 5000);\n    }\n  }\n}\n","import { Client } from \"discord-rpc\";\r\nimport { Plugin, PluginManifest, TFile } from \"obsidian\";\r\nimport { Logger } from \"./logger\";\r\nimport { DiscordRPCSettings, PluginState } from \"./settings/settings\";\r\nimport { DiscordRPCSettingsTab } from \"./settings/settings-tab\";\r\nimport { StatusBar } from \"./status-bar\";\r\n\r\nexport default class ObsidianDiscordRPC extends Plugin {\r\n  public state: PluginState;\r\n  public settings: DiscordRPCSettings;\r\n  public statusBar: StatusBar;\r\n  public rpc: Client;\r\n  public logger: Logger = new Logger();\r\n  public currentFile: TFile;\r\n  public loadedTime: Date;\r\n\r\n  setState(state: PluginState) {\r\n    this.state = state;\r\n  }\r\n\r\n  getState(): PluginState {\r\n    return this.state;\r\n  }\r\n\r\n  public getApp(): any {\r\n    return this.app;\r\n  }\r\n\r\n  public getPluginManifest(): PluginManifest {\r\n    return this.manifest;\r\n  }\r\n\r\n  async onload() {\r\n    let statusBarEl = this.addStatusBarItem();\r\n    this.statusBar = new StatusBar(statusBarEl);\r\n\r\n    this.settings = (await this.loadData()) || new DiscordRPCSettings();\r\n\r\n    this.registerEvent(\r\n      this.app.workspace.on(\"file-open\", this.onFileOpen, this)\r\n    );\r\n\r\n    this.registerDomEvent(statusBarEl, \"click\", async () => {\r\n      if (this.getState() == PluginState.disconnected) {\r\n        await this.connectDiscord();\r\n      } else if (this.getState() == PluginState.connected){\r\n        await this.disconnectDiscord();\r\n      }\r\n    });\r\n\r\n    this.addSettingTab(new DiscordRPCSettingsTab(this.app, this));\r\n\r\n    this.addCommand({\r\n      id: \"reconnect-discord\",\r\n      name: \"Reconnect to Discord\",\r\n      callback: async () => await this.connectDiscord(),\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"disconnect-discord\",\r\n      name: \"Disconnect from Discord\",\r\n      callback: async () => await this.disconnectDiscord(),\r\n    })\r\n\r\n    if(this.settings.connectOnStart){\r\n      await this.connectDiscord();\r\n\r\n      let activeLeaf = this.app.workspace.activeLeaf;\r\n      let files: TFile[] = this.app.vault.getMarkdownFiles();\r\n\r\n      files.forEach((file) => {\r\n        if (file.basename === activeLeaf.getDisplayText()) {\r\n          this.onFileOpen(file);\r\n        }\r\n      });\r\n    } else {\r\n      this.setState(PluginState.disconnected);\r\n      this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n    }\r\n    \r\n  }\r\n\r\n  async onFileOpen(file: TFile) {\r\n    this.currentFile = file;\r\n    if (this.getState() === PluginState.connected) {\r\n      await this.setActivity(\r\n        this.app.vault.getName(),\r\n        file.basename,\r\n        file.extension\r\n      );\r\n    }\r\n  }\r\n\r\n  async onunload() {\r\n    await this.saveData(this.settings);\r\n    this.rpc.clearActivity();\r\n    this.rpc.destroy();\r\n  }\r\n\r\n  async connectDiscord(): Promise<void> {\r\n    this.loadedTime = new Date();\r\n    \r\n    this.rpc = new Client({\r\n      transport: \"ipc\",\r\n    });\r\n\r\n    this.setState(PluginState.connecting);\r\n    this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n\r\n    this.rpc.once(\"ready\", () => {\r\n      this.setState(PluginState.connected);\r\n      this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n      this.logger.log(\"Connected to Discord\", this.settings.showPopups);\r\n    });\r\n\r\n    try {\r\n      await this.rpc.login({\r\n        clientId: \"763813185022197831\",\r\n      });\r\n      await this.setActivity(this.app.vault.getName(), \"...\", \"\");\r\n    } catch (error) {\r\n      this.setState(PluginState.disconnected);\r\n      this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n      this.logger.log(\"Failed to connect to Discord\", this.settings.showPopups);\r\n    }\r\n  }\r\n\r\n  async disconnectDiscord(): Promise<void> {\r\n    this.rpc.clearActivity();\r\n    this.rpc.destroy();\r\n    this.setState(PluginState.disconnected);\r\n    this.statusBar.displayState(this.getState(), this.settings.autoHideStatusBar);\r\n    this.logger.log(\"Disconnected from Discord\", this.settings.showPopups);\r\n  }\r\n\r\n  async setActivity(\r\n    vaultName: string,\r\n    fileName: string,\r\n    fileExtension: string\r\n  ): Promise<void> {\r\n    if (this.getState() === PluginState.connected) {\r\n      let vault: string;\r\n      if (this.settings.customVaultName === \"\") {\r\n        vault = vaultName;\r\n      } else {\r\n        vault = this.settings.customVaultName;\r\n      }\r\n\r\n      let file: string;\r\n      if (this.settings.showFileExtension) {\r\n        file = fileName + \".\" + fileExtension;\r\n      } else {\r\n        file = fileName;\r\n      }\r\n\r\n      let date: Date;\r\n      if (this.settings.useLoadedTime) {\r\n        date = this.loadedTime;\r\n      } else {\r\n        date = new Date();\r\n      }\r\n\r\n      if (this.settings.showVaultName && this.settings.showCurrentFileName) {\r\n        await this.rpc.setActivity({\r\n          details: `Editing ${file}`,\r\n          state: `Vault: ${vault}`,\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      } else if (this.settings.showVaultName) {\r\n        await this.rpc.setActivity({\r\n          state: `Vault: ${vault}`,\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      } else if (this.settings.showCurrentFileName) {\r\n        await this.rpc.setActivity({\r\n          details: `Editing ${file}`,\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      } else {\r\n        await this.rpc.setActivity({\r\n          startTimestamp: date,\r\n          largeImageKey: \"logo\",\r\n          largeImageText: \"Obsidian\",\r\n        });\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"names":["require$$0","uuid","net","fetch","EventEmitter","require$$1","setTimeout","require$$2","Notice","Setting","PluginSettingTab","Client","Plugin"],"mappings":"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"} diff --git a/.obsidian/plugins/obsidian-discordrpc/manifest.json b/.obsidian/plugins/obsidian-discordrpc/manifest.json new file mode 100644 index 0000000..3d17482 --- /dev/null +++ b/.obsidian/plugins/obsidian-discordrpc/manifest.json @@ -0,0 +1,9 @@ +{ + "id": "obsidian-discordrpc", + "name": "Discord Rich Presence", + "version": "1.5.0", + "description": "Update your Discord Status to show your friends what you are working on in Obsidian. With Discord Rich Presence.", + "author": "Luke Leppan", + "authorUrl": "https://lukeleppan.com", + "isDesktopOnly": false +} diff --git a/.obsidian/workspace b/.obsidian/workspace index 0c8fcf7..2afed95 100644 --- a/.obsidian/workspace +++ b/.obsidian/workspace @@ -4,7 +4,7 @@ "type": "split", "children": [ { - "id": "624fc6cedfec68e9", + "id": "2df3f86afa97d7ff", "type": "leaf", "state": { "type": "markdown", @@ -148,7 +148,7 @@ } } ], - "currentTab": 2 + "currentTab": 5 }, { "id": "7804475bf051d7e7", @@ -166,10 +166,9 @@ } ], "direction": "horizontal", - "width": 303, - "collapsed": true + "width": 303 }, - "active": "624fc6cedfec68e9", + "active": "2df3f86afa97d7ff", "lastOpenFiles": [ "Daily/03.07.2022.md", "Firmen/Steinemann Technology/Notes/Penta/Änderungen.md",