webamp 0.0.0-next-a180155 → 0.0.0-next-c1d68b5

package/built/types/js/mediaSession.d.ts

@@ -0,0 +1,2 @@
+import type WebampLazy from "./webampLazy";
+export default function enableMediaSession(webamp: WebampLazy): void;

package/built/types/js/setImmediate.d.ts

@@ -0,0 +1 @@
+export declare function setImmediate(callback: Function): number;

package/built/types/js/types.d.ts

@@ -584,6 +584,15 @@ export interface Options {
     handleAddUrlEvent?: () => Track[] | null | Promise<Track[] | null>;
     handleLoadListEvent?: () => Track[] | null | Promise<Track[] | null>;
     handleSaveListEvent?: (tracks: Track[]) => null | Promise<null>;
+    /**
+     * Have Webamp attempt to connect to the browser's media session API.
+     *
+     * This allows OS/hardware level media controls like play/pause/next/previous
+     * and lock screen "current track" information to work with Webamp.
+     *
+     * https://developer.mozilla.org/en-US/docs/Web/API/Media_Session_API
+     */
+    enableMediaSession?: boolean;
 }
 /**
  * Specifies the initial position and size of a the Winamp windows.

package/built/types/js/webampLazy.d.ts

@@ -61,10 +61,18 @@ declare class Webamp {
      * Check if shuffle is enabled
      */
     isShuffleEnabled(): boolean;
+    /**
+     * Toggle shuffle mode between enabled and disabled.
+     */
+    toggleShuffle(): void;
     /**
      * Check if repeat is enabled
      */
     isRepeatEnabled(): boolean;
+    /**
+     * Toggle repeat mode between enabled and disabled.
+     */
+    toggleRepeat(): void;
     /**
      * Play the next track
      */

package/built/webamp.bundle.js

@@ -43991,6 +43991,57 @@
 	    }
 	}
 
+	function enableMediaSession(webamp) {
+	    if ("mediaSession" in navigator) {
+	        /* global MediaMetadata */
+	        webamp.onTrackDidChange((track) => {
+	            if (track == null) {
+	                return;
+	            }
+	            const { metaData: { title, artist, album, albumArtUrl }, } = track;
+	            navigator.mediaSession.metadata = new MediaMetadata({
+	                title: title ?? undefined,
+	                artist: artist ?? undefined,
+	                album: album ?? undefined,
+	                artwork: albumArtUrl
+	                    ? [
+	                        {
+	                            src: albumArtUrl,
+	                            // We don't currently know these.
+	                            // sizes: "96x96",
+	                            // type: "image/png"
+	                        },
+	                    ]
+	                    : [],
+	            });
+	        });
+	        // @ts-ignore TypeScript does not know about the Media Session API: https://github.com/Microsoft/TypeScript/issues/19473
+	        navigator.mediaSession.setActionHandler("play", () => {
+	            webamp.play();
+	        });
+	        // @ts-ignore TypeScript does not know about the Media Session API: https://github.com/Microsoft/TypeScript/issues/19473
+	        navigator.mediaSession.setActionHandler("pause", () => {
+	            webamp.pause();
+	        });
+	        // @ts-ignore TypeScript does not know about the Media Session API: https://github.com/Microsoft/TypeScript/issues/19473
+	        navigator.mediaSession.setActionHandler("seekbackward", () => {
+	            webamp.seekBackward(10);
+	        });
+	        // @ts-ignore TypeScript does not know about the Media Session API: https://github.com/Microsoft/TypeScript/issues/19473
+	        navigator.mediaSession.setActionHandler("seekforward", () => {
+	            webamp.seekForward(10);
+	        });
+	        // @ts-ignore TypeScript does not know about the Media Session API: https://github.com/Microsoft/TypeScript/issues/19473
+	        navigator.mediaSession.setActionHandler("previoustrack", () => {
+	            webamp.previousTrack();
+	        });
+	        // @ts-ignore TypeScript does not know about the Media Session API: https://github.com/Microsoft/TypeScript/issues/19473
+	        navigator.mediaSession.setActionHandler("nexttrack", () => {
+	            webamp.nextTrack();
+	        });
+	    }
+	}
+
 	let Webamp$1 = class Webamp {
 	    static VERSION = "1.5.0";
 	    _actionEmitter;
@@ -44018,6 +44069,9 @@
 	        this._actionEmitter = new Emitter();
 	        this.options = options;
 	        const { initialTracks, initialSkin, availableSkins, enableHotkeys = false, zIndex, requireJSZip, requireMusicMetadata, handleTrackDropEvent, handleAddUrlEvent, handleLoadListEvent, handleSaveListEvent, enableDoubleSizeMode, __butterchurnOptions, __customMediaClass, } = this.options;
+	        if (options.enableMediaSession) {
+	            enableMediaSession(this);
+	        }
 	        // TODO: Make this much cleaner
 	        let convertPreset = null;
 	        if (__butterchurnOptions != null) {
@@ -44140,12 +44194,24 @@
 	    isShuffleEnabled() {
 	        return getShuffle(this.store.getState());
 	    }
+	    /**
+	     * Toggle shuffle mode between enabled and disabled.
+	     */
+	    toggleShuffle() {
+	        this.store.dispatch(toggleShuffle());
+	    }
 	    /**
 	     * Check if repeat is enabled
 	     */
 	    isRepeatEnabled() {
 	        return getRepeat(this.store.getState());
 	    }
+	    /**
+	     * Toggle repeat mode between enabled and disabled.
+	     */
+	    toggleRepeat() {
+	        this.store.dispatch(toggleRepeat());
+	    }
 	    /**
 	     * Play the next track
 	     */
@@ -44367,6 +44433,125 @@
 	// @ts-ignore
 	window.Webamp = Webamp$1;
 
+	// A Fork of the NPM module `setimmediate`
+	// I've adapted this to only include the browser implementation and to not
+	// mutate the global object and instead export the `setImmediate` function.
+	let nextHandle = 1; // Spec says greater than zero
+	const tasksByHandle = {};
+	let currentlyRunningATask = false;
+	let registerImmediate;
+	function setImmediate$1(callback) {
+	    // Copy function arguments
+	    const args = new Array(arguments.length - 1);
+	    for (let i = 0; i < args.length; i++) {
+	        args[i] = arguments[i + 1];
+	    }
+	    // Store and register the task
+	    const task = { callback: callback, args: args };
+	    tasksByHandle[nextHandle] = task;
+	    registerImmediate(nextHandle);
+	    return nextHandle++;
+	}
+	function clearImmediate(handle) {
+	    delete tasksByHandle[handle];
+	}
+	function run(task) {
+	    const callback = task.callback;
+	    const args = task.args;
+	    switch (args.length) {
+	        case 0:
+	            callback();
+	            break;
+	        case 1:
+	            callback(args[0]);
+	            break;
+	        case 2:
+	            callback(args[0], args[1]);
+	            break;
+	        case 3:
+	            callback(args[0], args[1], args[2]);
+	            break;
+	        default:
+	            // eslint-disable-next-line prefer-spread
+	            callback.apply(undefined, args);
+	            break;
+	    }
+	}
+	function runIfPresent(handle) {
+	    // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
+	    // So if we're currently running a task, we'll need to delay this invocation.
+	    if (currentlyRunningATask) {
+	        // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
+	        // "too much recursion" error.
+	        setTimeout(runIfPresent, 0, handle);
+	    }
+	    else {
+	        const task = tasksByHandle[handle];
+	        if (task) {
+	            currentlyRunningATask = true;
+	            try {
+	                run(task);
+	            }
+	            finally {
+	                clearImmediate(handle);
+	                currentlyRunningATask = false;
+	            }
+	        }
+	    }
+	}
+	function canUsePostMessage() {
+	    // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+	    // where `global.postMessage` means something completely different and can't be used for this purpose.
+	    if (!window.importScripts) {
+	        let postMessageIsAsynchronous = true;
+	        const oldOnMessage = window.onmessage;
+	        window.onmessage = function () {
+	            postMessageIsAsynchronous = false;
+	        };
+	        window.postMessage("", "*");
+	        window.onmessage = oldOnMessage;
+	        return postMessageIsAsynchronous;
+	    }
+	}
+	function installPostMessageImplementation() {
+	    // Installs an event handler on `global` for the `message` event: see
+	    // * https://developer.mozilla.org/en/DOM/window.postMessage
+	    // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
+	    const messagePrefix = `setImmediate$${Math.random()}$`;
+	    window.addEventListener("message", (event) => {
+	        if (event.source === window &&
+	            typeof event.data === "string" &&
+	            event.data.indexOf(messagePrefix) === 0) {
+	            runIfPresent(+event.data.slice(messagePrefix.length));
+	        }
+	    }, false);
+	    registerImmediate = function (handle) {
+	        window.postMessage(messagePrefix + handle, "*");
+	    };
+	}
+	function installSetTimeoutImplementation() {
+	    registerImmediate = function (handle) {
+	        setTimeout(runIfPresent, 0, handle);
+	    };
+	}
+	if (canUsePostMessage()) {
+	    // For non-IE10 modern browsers
+	    installPostMessageImplementation();
+	}
+	else {
+	    // For older browsers
+	    installSetTimeoutImplementation();
+	}
+
+	var utilsExports = requireUtils();
+	var Utils = /*@__PURE__*/getDefaultExportFromCjs(utilsExports);
+
+	// @ts-ignore
+	Utils.delay = function (callback, args, self) {
+	    setImmediate$1(() => {
+	        callback.apply(self || null, args || []);
+	    });
+	};
 	class Webamp extends Webamp$1 {
 	    constructor(options) {
 	        super({