Merge branch 'master' into master

plugins/audio-compressor/front.js

@@ -0,0 +1,25 @@
+const applyCompressor = () => {
+	const videoElement = document.querySelector("video");
+
+	// If video element is not loaded yet try again
+	if(videoElement === null) {
+		setTimeout(applyCompressor, 500);
+		return;
+	}
+
+	const audioContext = new AudioContext();
+	
+	let compressor = audioContext.createDynamicsCompressor();
+	compressor.threshold.value = -50;
+	compressor.ratio.value = 12;
+	compressor.knee.value = 40;
+	compressor.attack.value = 0;
+	compressor.release.value = 0.25;
+
+	const source = audioContext.createMediaElementSource(videoElement);
+
+	source.connect(compressor);
+	compressor.connect(audioContext.destination);
+};
+
+module.exports = applyCompressor;

plugins/auto-confirm-when-paused/front.js

@@ -1,12 +0,0 @@
-// Define global chrome object to be compliant with the extension code
-global.chrome = {
-	runtime: {
-		getManifest: () => ({
-			version: 1
-		})
-	}
-};
-
-module.exports = () => {
-	require("YoutubeNonStop/autoconfirm.js");
-};

plugins/discord/back.js

@@ -145,7 +145,4 @@ module.exports.clear = () => {
 };
 module.exports.connect = connect;
 module.exports.registerRefresh = (cb) => refreshCallbacks.push(cb);
-/**
- * @type {Info}
- */
-module.exports.info = Object.defineProperties({}, Object.keys(info).reduce((o, k) => ({ ...o, [k]: { enumerable: true, get: () => info[k] } }), {}));
+module.exports.isConnected = () => info.rpc !== null;

plugins/discord/menu.js

@@ -1,6 +1,6 @@
 const { setOptions } = require("../../config/plugins");
 const { edit } = require("../../config");
-const { clear, info, connect, registerRefresh } = require("./back");
+const { clear, connect, registerRefresh, isConnected } = require("./back");
 
 let hasRegisterred = false;
 
@@ -12,8 +12,8 @@ module.exports = (win, options, refreshMenu) => {
 
 	return [
 		{
-			label: info.rpc !== null ? "Connected" : "Reconnect",
-			enabled: info.rpc === null,
+			label: isConnected() ? "Connected" : "Reconnect",
+			enabled: !isConnected(),
 			click: connect,
 		},
 		{

plugins/precise-volume/back.js

@@ -1,23 +1,9 @@
-const { isEnabled } = require("../../config/plugins");
-
 /*
 This is used to determine if plugin is actually active
 (not if its only enabled in options)
 */
 let enabled = false;
 
-module.exports = (win) => {
-	enabled = true;
+module.exports = () => enabled = true;
 
-	// youtube-music register some of the target listeners after DOMContentLoaded
-	// did-finish-load is called after all elements finished loading, including said listeners
-	// Thats the reason the timing is controlled from main
-	win.webContents.once("did-finish-load", () => {
-		win.webContents.send("restoreAddEventListener");
-		win.webContents.send("setupVideoPlayerVolumeMousewheel", !isEnabled("hide-video-player"));
-	});
-};
-
-module.exports.enabled = () => {
-	return enabled;
-};
+module.exports.enabled = () => enabled;

plugins/precise-volume/front.js

@@ -3,27 +3,73 @@ const { ipcRenderer, remote } = require("electron");
 const { setOptions } = require("../../config/plugins");
 
 function $(selector) { return document.querySelector(selector); }
+let api;
 
 module.exports = (options) => {
+	document.addEventListener('apiLoaded', e => {
+		api = e.detail;
+		firstRun(options);
+	})
+};
+
+/** Restore saved volume and setup tooltip */
+function firstRun(options) {
+	if (typeof options.savedVolume === "number") {
+		// Set saved volume as tooltip
+		setTooltip(options.savedVolume);
+
+		if (api.getVolume() !== options.savedVolume) {
+			api.setVolume(options.savedVolume);
+		}
+	}
 
 	setupPlaybar(options);
 
-	setupSliderObserver(options);
-
 	setupLocalArrowShortcuts(options);
 
-	if (options.globalShortcuts?.enabled) {
-		setupGlobalShortcuts(options);
+	setupGlobalShortcuts(options);
+
+	const noVid = $("#main-panel")?.computedStyleMap().get("display").value === "none";
+	injectVolumeHud(noVid);
+	if (!noVid) {
+		setupVideoPlayerOnwheel(options);
+	}
+}
+
+function injectVolumeHud(noVid) {
+	if (noVid) {
+		const position = "top: 18px; right: 60px; z-index: 999; position: absolute;";
+		const mainStyle = "font-size: xx-large; padding: 10px; transition: opacity 1s";
+
+		$(".center-content.ytmusic-nav-bar").insertAdjacentHTML("beforeend",
+			`<span id="volumeHud" style="${position + mainStyle}"></span>`)
+	} else {
+		const position = `top: 10px; left: 10px; z-index: 999; position: absolute;`;
+		const mainStyle = "font-size: xxx-large; padding: 10px; transition: opacity 0.6s; webkit-text-stroke: 1px black; font-weight: 600;";
+
+		$("#song-video").insertAdjacentHTML('afterend',
+			`<span id="volumeHud" style="${position + mainStyle}"></span>`)
+	}
+}
+
+let hudFadeTimeout;
+
+function showVolumeHud(volume) {
+	let volumeHud = $("#volumeHud");
+	if (!volumeHud) return;
+
+	volumeHud.textContent = volume + '%';
+	volumeHud.style.opacity = 1;
+
+	if (hudFadeTimeout) {
+		clearTimeout(hudFadeTimeout);
 	}
 
-	firstRun(options);
-
-	// This way the ipc listener gets cleared either way
-	ipcRenderer.once("setupVideoPlayerVolumeMousewheel", (_event, toEnable) => {
-		if (toEnable)
-			setupVideoPlayerOnwheel(options);
-	});
-};
+	hudFadeTimeout = setTimeout(() => {
+		volumeHud.style.opacity = 0;
+		hudFadeTimeout = null;
+	}, 2000);
+}
 
 /** Add onwheel event to video player */
 function setupVideoPlayerOnwheel(options) {
@@ -34,35 +80,20 @@ function setupVideoPlayerOnwheel(options) {
 	});
 }
 
-function toPercent(volume) {
-	return Math.round(Number.parseFloat(volume) * 100);
-}
-
 function saveVolume(volume, options) {
 	options.savedVolume = volume;
-	setOptions("precise-volume", options);
+	writeOptions(options);
 }
 
-/** Restore saved volume and setup tooltip */
-function firstRun(options) {
-	const videoStream = $(".video-stream");
-	const slider = $("#volume-slider");
-	// Those elements load abit after DOMContentLoaded
-	if (videoStream && slider) {
-		// Set saved volume IF it pass checks
-		if (options.savedVolume
-			&& options.savedVolume >= 0 && options.savedVolume <= 100
-			&& Math.abs(slider.value - options.savedVolume) < 5
-			// If plugin was disabled and volume changed then diff>4
-		) {
-			videoStream.volume = options.savedVolume / 100;
-			slider.value = options.savedVolume;
-		}
-		// Set current volume as tooltip
-		setTooltip(toPercent(videoStream.volume));
-	} else {
-		setTimeout(firstRun, 500, options); // Try again in 500 milliseconds
-	}
+//without this function it would rewrite config 20 time when volume change by 20
+let writeTimeout;
+function writeOptions(options) {
+	if (writeTimeout) clearTimeout(writeTimeout);
+
+	writeTimeout = setTimeout(() => {
+		setOptions("precise-volume", options);
+		writeTimeout = null;
+	}, 1500)
 }
 
 /** Add onwheel event to play bar and also track if play bar is hovered*/
@@ -83,32 +114,63 @@ function setupPlaybar(options) {
 	playerbar.addEventListener("mouseleave", () => {
 		playerbar.classList.remove("on-hover");
 	});
+
+	setupSliderObserver(options);
+}
+
+/** Save volume + Update the volume tooltip when volume-slider is manually changed */
+function setupSliderObserver(options) {
+	const sliderObserver = new MutationObserver(mutations => {
+		for (const mutation of mutations) {
+			// This checks that volume-slider was manually set
+			if (mutation.oldValue !== mutation.target.value &&
+				(typeof options.savedVolume !== "number" || Math.abs(options.savedVolume - mutation.target.value) > 4)) {
+				// Diff>4 means it was manually set
+				setTooltip(mutation.target.value);
+				saveVolume(mutation.target.value, options);
+			}
+		}
+	});
+
+	// Observing only changes in 'value' of volume-slider
+	sliderObserver.observe($("#volume-slider"), {
+		attributeFilter: ["value"],
+		attributeOldValue: true
+	});
 }
 
 /** if (toIncrease = false) then volume decrease */
 function changeVolume(toIncrease, options) {
-	// Need to change both the actual volume and the slider
-	const videoStream = $(".video-stream");
-	const slider = $("#volume-slider");
 	// Apply volume change if valid
-	const steps = (options.steps || 1) / 100;
-	videoStream.volume = toIncrease ?
-		Math.min(videoStream.volume + steps, 1) :
-		Math.max(videoStream.volume - steps, 0);
+	const steps = (options.steps || 1);
+	api.setVolume(toIncrease ?
+		Math.min(api.getVolume() + steps, 100) :
+		Math.max(api.getVolume() - steps, 0));
 
 	// Save the new volume
-	saveVolume(toPercent(videoStream.volume), options);
-	// Slider value automatically rounds to multiples of 5
-	slider.value = options.savedVolume;
+	saveVolume(api.getVolume(), options);
+
+	// change slider position (important)
+	updateVolumeSlider(options);
+
 	// Change tooltips to new value
 	setTooltip(options.savedVolume);
-	// Show volume slider on volume change
-	showVolumeSlider(slider);
+	// Show volume slider
+	showVolumeSlider();
+	// Show volume HUD
+	showVolumeHud(options.savedVolume);
+}
+
+function updateVolumeSlider(options) {
+	// Slider value automatically rounds to multiples of 5
+	$("#volume-slider").value = options.savedVolume > 0 && options.savedVolume < 5 ?
+		5 : options.savedVolume;
 }
 
 let volumeHoverTimeoutID;
 
-function showVolumeSlider(slider) {
+function showVolumeSlider() {
+	const slider = $("#volume-slider");
 	// This class display the volume slider if not in minimized mode
 	slider.classList.add("on-hover");
 	// Reset timeout if previous one hasn't completed
@@ -124,27 +186,6 @@ function showVolumeSlider(slider) {
 	}, 3000);
 }
 
-/** Save volume + Update the volume tooltip when volume-slider is manually changed */
-function setupSliderObserver(options) {
-	const sliderObserver = new MutationObserver(mutations => {
-		for (const mutation of mutations) {
-			// This checks that volume-slider was manually set
-			if (mutation.oldValue !== mutation.target.value &&
-				(!options.savedVolume || Math.abs(options.savedVolume - mutation.target.value) > 4)) {
-				// Diff>4 means it was manually set
-				setTooltip(mutation.target.value);
-				saveVolume(mutation.target.value, options);
-			}
-		}
-	});
-
-	// Observing only changes in 'value' of volume-slider
-	sliderObserver.observe($("#volume-slider"), {
-		attributeFilter: ["value"],
-		attributeOldValue: true
-	});
-}
-
 // Set new volume as tooltip for volume slider and icon + expanding slider (appears when window size is small)
 const tooltipTargets = [
 	"#volume-slider",

plugins/precise-volume/menu.js

@@ -1,13 +1,16 @@
 const { enabled } = require("./back");
 const { setOptions } = require("../../config/plugins");
+const prompt = require("custom-electron-prompt");
+const promptOptions = require("../../providers/prompt-options");
+
 
 module.exports = (win, options) => [
 	{
-		label: "Arrowkeys controls",
+		label: "Local Arrowkeys Controls",
 		type: "checkbox",
 		checked: !!options.arrowsShortcut,
-		click: (item) => {
-			// Dynamically change setting if plugin enabled
+		click: item => {
+			// Dynamically change setting if plugin is enabled
 			if (enabled()) {
 				win.webContents.send("setArrowsShortcut", item.checked);
 			} else { // Fallback to usual method if disabled
@@ -15,5 +18,61 @@ module.exports = (win, options) => [
 				setOptions("precise-volume", options);
 			}
 		}
+	},
+	{
+		label: "Global Hotkeys",
+		type: "checkbox",
+		checked: !!options.globalShortcuts.volumeUp || !!options.globalShortcuts.volumeDown,
+		click: item => promptGlobalShortcuts(win, options, item)
+	},
+	{
+		label: "Set Custom Volume Steps",
+		click: () => promptVolumeSteps(win, options)
 	}
 ];
+
+// Helper function for globalShortcuts prompt
+const kb = (label_, value_, default_) => { return { value: value_, label: label_, default: default_ || undefined }; };
+
+async function promptVolumeSteps(win, options) {
+	const output = await prompt({
+		title: "Volume Steps",
+		label: "Choose Volume Increase/Decrease Steps",
+		value: options.steps || 1,
+		type: "counter",
+		counterOptions: { minimum: 0, maximum: 100, multiFire: true },
+		width: 380,
+		...promptOptions()
+	}, win)
+
+	if (output || output === 0) { // 0 is somewhat valid
+		options.steps = output;
+		setOptions("precise-volume", options);
+	}
+}
+
+async function promptGlobalShortcuts(win, options, item) {
+	const output = await prompt({
+		title: "Global Volume Keybinds",
+		label: "Choose Global Volume Keybinds:",
+		type: "keybind",
+		keybindOptions: [
+			kb("Increase Volume", "volumeUp", options.globalShortcuts?.volumeUp),
+			kb("Decrease Volume", "volumeDown", options.globalShortcuts?.volumeDown)
+		],
+		...promptOptions()
+	}, win)
+
+	if (output) {
+		for (const { value, accelerator } of output) {
+			options.globalShortcuts[value] = accelerator;
+		}
+
+		setOptions("precise-volume", options);
+
+		item.checked = !!options.globalShortcuts.volumeUp || !!options.globalShortcuts.volumeDown;
+	} else {
+		// Reset checkbox if prompt was canceled
+		item.checked = !item.checked;
+	}
+}

plugins/precise-volume/preload.js

@@ -24,10 +24,10 @@ function overrideAddEventListener() {
 
 module.exports = () => {
     overrideAddEventListener();
-    // Restore original function after did-finish-load to avoid keeping Element.prototype altered
-    ipcRenderer.once("restoreAddEventListener", () => { // Called from main to make sure page is completly loaded
+    // Restore original function after finished loading to avoid keeping Element.prototype altered
+    window.addEventListener('load', () => {
         Element.prototype.addEventListener = Element.prototype._addEventListener;
         Element.prototype._addEventListener = undefined;
         ignored = undefined;
-    });
+    }, { once: true });
 };

plugins/shortcuts/back.js

@@ -1,9 +1,11 @@
 const { globalShortcut } = require("electron");
 const is = require("electron-is");
 const electronLocalshortcut = require("electron-localshortcut");
-
 const getSongControls = require("../../providers/song-controls");
 const { setupMPRIS } = require("./mpris");
+const registerCallback = require("../../providers/song-info");
+
+let player;
 
 function _registerGlobalShortcut(webContents, shortcut, action) {
 	globalShortcut.register(shortcut, () => {
@@ -21,47 +23,89 @@ function registerShortcuts(win, options) {
 	const songControls = getSongControls(win);
 	const { playPause, next, previous, search } = songControls;
 
-	_registerGlobalShortcut(win.webContents, "MediaPlayPause", playPause);
-	_registerGlobalShortcut(win.webContents, "MediaNextTrack", next);
-	_registerGlobalShortcut(win.webContents, "MediaPreviousTrack", previous);
+	if (options.overrideMediaKeys) {
+		_registerGlobalShortcut(win.webContents, "MediaPlayPause", playPause);
+		_registerGlobalShortcut(win.webContents, "MediaNextTrack", next);
+		_registerGlobalShortcut(win.webContents, "MediaPreviousTrack", previous);
+	}
+
 	_registerLocalShortcut(win, "CommandOrControl+F", search);
 	_registerLocalShortcut(win, "CommandOrControl+L", search);
+	registerCallback(songInfo => {
+		if (player) {
+			player.metadata = {
+				'mpris:length': songInfo.songDuration * 60 * 1000 * 1000, // In microseconds
+				'mpris:artUrl': songInfo.imageSrc,
+				'xesam:title': songInfo.title,
+				'xesam:artist': songInfo.artist
+			};
+			if (!songInfo.isPaused) {
+				player.playbackStatus = "Playing"
+			}
+		}
+	}
+	)
 
 	if (is.linux()) {
 		try {
-			const player = setupMPRIS();
+			const MPRISPlayer = setupMPRIS();
 
-			player.on("raise", () => {
+			MPRISPlayer.on("raise", () => {
 				win.setSkipTaskbar(false);
 				win.show();
 			});
-			player.on("playpause", playPause);
-			player.on("next", next);
-			player.on("previous", previous);
+			MPRISPlayer.on("play", () => {
+				if (MPRISPlayer.playbackStatus !== 'Playing') {
+					MPRISPlayer.playbackStatus = 'Playing';
+					playPause()
+				}
+			});
+			MPRISPlayer.on("pause", () => {
+				if (MPRISPlayer.playbackStatus !== 'Paused') {
+					MPRISPlayer.playbackStatus = 'Paused';
+					playPause()
+				}
+			});
+			MPRISPlayer.on("next", () => {
+				next()
+			});
+			MPRISPlayer.on("previous", () => {
+				previous()
+			});
+
+			player = MPRISPlayer
+
 		} catch (e) {
 			console.warn("Error in MPRIS", e);
 		}
 	}
 
 	const { global, local } = options;
-	(global || []).forEach(({ shortcut, action }) => {
-		console.debug("Registering global shortcut", shortcut, ":", action);
-		if (!action || !songControls[action]) {
-			console.warn("Invalid action", action);
-			return;
-		}
+	const shortcutOptions = { global, local };
 
-		_registerGlobalShortcut(win.webContents, shortcut, songControls[action]);
-	});
-	(local || []).forEach(({ shortcut, action }) => {
-		console.debug("Registering local shortcut", shortcut, ":", action);
-		if (!action || !songControls[action]) {
-			console.warn("Invalid action", action);
-			return;
-		}
+	for (const optionType in shortcutOptions) {
+		registerAllShortcuts(shortcutOptions[optionType], optionType);
+	}
 
-		_registerLocalShortcut(win, shortcut, songControls[action]);
-	});
+	function registerAllShortcuts(container, type) {
+		for (const action in container) {
+			if (!container[action]) {
+				continue; // Action accelerator is empty
+			}
+
+			console.debug(`Registering ${type} shortcut`, container[action], ":", action);
+			if (!songControls[action]) {
+				console.warn("Invalid action", action);
+				continue;
+			}
+
+			if (type === "global") {
+				_registerGlobalShortcut(win.webContents, container[action], songControls[action]);
+			} else { // type === "local"
+				_registerLocalShortcut(win, local[action], songControls[action]);
+			}
+		}
+	}
 }
 
 module.exports = registerShortcuts;

plugins/shortcuts/menu.js

@@ -0,0 +1,53 @@
+const { setOptions } = require("../../config/plugins");
+const prompt = require("custom-electron-prompt");
+const promptOptions = require("../../providers/prompt-options");
+
+module.exports = (win, options) => [
+	{
+		label: "Set Global Song Controls",
+		click: () => promptKeybind(options, win)
+	},
+	{
+		label: "Override MediaKeys",
+		type: "checkbox",
+		checked: options.overrideMediaKeys,
+		click: item => setOption(options, "overrideMediaKeys", item.checked)
+	}
+];
+
+function setOption(options, key = null, newValue = null) {
+	if (key && newValue !== null) {
+		options[key] = newValue;
+	}
+
+	setOptions("shortcuts", options);
+}
+
+// Helper function for keybind prompt
+const kb = (label_, value_, default_) => { return { value: value_, label: label_, default: default_ }; };
+
+async function promptKeybind(options, win) {
+	const output = await prompt({
+		title: "Global Keybinds",
+		label: "Choose Global Keybinds for Songs Control:",
+		type: "keybind",
+		keybindOptions: [ // If default=undefined then no default is used
+			kb("Previous", "previous", options.global?.previous),
+			kb("Play / Pause", "playPause", options.global?.playPause),
+			kb("Next", "next", options.global?.next)
+		],
+		height: 270,
+		...promptOptions()
+	}, win);
+
+	if (output) {
+		if (!options.global) {
+			options.global = {};
+		}
+		for (const { value, accelerator } of output) {
+			options.global[value] = accelerator;
+		}
+		setOption(options);
+	}
+	// else -> pressed cancel
+}