magmastream 2.9.0-dev.46 → 2.9.0-dev.48

package/dist/statestorage/MemoryQueue.js

@@ -26,78 +26,7 @@ class MemoryQueue extends Array {
         /** The guild property. */
         this.guildId = guildId;
     }
-    /**
-     * @returns The current track.
-     */
-    async getCurrent() {
-        return this.current;
-    }
-    /**
-     * @param track The track to set.
-     */
-    async setCurrent(track) {
-        this.current = track;
-    }
-    /**
-     * @returns The previous tracks.
-     */
-    async getPrevious() {
-        return [...this.previous];
-    }
-    async addPrevious(track) {
-        if (Array.isArray(track)) {
-            const newTracks = track.filter((t) => !this.previous.some((p) => p.identifier === t.identifier));
-            this.previous.unshift(...newTracks);
-        }
-        else {
-            const exists = this.previous.some((p) => p.identifier === track.identifier);
-            if (!exists) {
-                this.previous.unshift(track);
-            }
-        }
-    }
-    /**
-     * @param tracks The tracks to set.
-     */
-    async setPrevious(tracks) {
-        this.previous = [...tracks];
-    }
-    /**
-     * @returns The newest track.
-     */
-    async popPrevious() {
-        return this.previous.shift() || null; // get newest track
-    }
-    /**
-     * Clears the previous tracks.
-     */
-    async clearPrevious() {
-        this.previous = [];
-    }
-    /**
-     * The total duration of the queue in milliseconds.
-     * This includes the duration of the currently playing track.
-     */
-    async duration() {
-        const current = this.current?.duration ?? 0;
-        return this.reduce((acc, cur) => acc + (cur.duration || 0), current);
-    }
-    /**
-     * The total size of tracks in the queue including the current track.
-     * This includes the current track if it is not null.
-     * @returns The total size of tracks in the queue including the current track.
-     */
-    async totalSize() {
-        return this.length + (this.current ? 1 : 0);
-    }
-    /**
-     * The size of tracks in the queue.
-     * This does not include the currently playing track.
-     * @returns The size of tracks in the queue.
-     */
-    async size() {
-        return this.length;
-    }
+    // #region Public
     /**
      * Adds a track to the queue.
      * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
@@ -176,42 +105,21 @@ class MemoryQueue extends Array {
             },
         });
     }
-    async remove(startOrPosition = 0, end) {
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        if (typeof end !== "undefined") {
-            // Validate input for `start` and `end`
-            if (isNaN(Number(startOrPosition)) || isNaN(Number(end))) {
-                throw new RangeError(`Invalid "start" or "end" parameter: start = ${startOrPosition}, end = ${end}`);
-            }
-            if (startOrPosition >= end || startOrPosition >= this.length) {
-                throw new RangeError("Invalid range: start should be less than end and within queue length.");
+    /**
+     * Adds a track to the previous tracks.
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     */
+    async addPrevious(track) {
+        if (Array.isArray(track)) {
+            const newTracks = track.filter((t) => !this.previous.some((p) => p.identifier === t.identifier));
+            this.previous.unshift(...newTracks);
+        }
+        else {
+            const exists = this.previous.some((p) => p.identifier === track.identifier);
+            if (!exists) {
+                this.previous.unshift(track);
             }
-            const removedTracks = this.splice(startOrPosition, end - startOrPosition);
-            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removedTracks.length} track(s) from player: ${this.guildId} from position ${startOrPosition} to ${end}.`);
-            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-                details: {
-                    type: "queue",
-                    action: "remove",
-                    tracks: removedTracks,
-                },
-            });
-            return removedTracks;
         }
-        // Single item removal when no end specified
-        const removedTrack = this.splice(startOrPosition, 1);
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed 1 track from player: ${this.guildId} from position ${startOrPosition}: ${JSON.stringify(removedTrack[0], null, 2)}`);
-        // Ensure removedTrack is an array for consistency
-        const tracksToEmit = removedTrack.length > 0 ? removedTrack : [];
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "remove",
-                tracks: tracksToEmit,
-            },
-        });
-        return removedTrack;
     }
     /**
      * Clears the queue.
@@ -235,68 +143,137 @@ class MemoryQueue extends Array {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Cleared the queue for: ${this.guildId}`);
     }
     /**
-     * Shuffles the queue.
-     * This will randomize the order of the tracks in the queue and emit a state update event.
+     * Clears the previous tracks.
      */
-    async shuffle() {
-        // Capture the current state of the player for event emission.
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        // Shuffle the queue.
-        for (let i = this.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [this[i], this[j]] = [this[j], this[i]];
+    async clearPrevious() {
+        this.previous = [];
+    }
+    /**
+     * Removes the first element from the queue.
+     */
+    async dequeue() {
+        return super.shift();
+    }
+    /**
+     * The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
+     */
+    async duration() {
+        const current = this.current?.duration ?? 0;
+        return this.reduce((acc, cur) => acc + (cur.duration || 0), current);
+    }
+    /**
+     * Adds the specified track or tracks to the front of the queue.
+     * @param track The track or tracks to add.
+     */
+    async enqueueFront(track) {
+        if (Array.isArray(track)) {
+            this.unshift(...track);
+        }
+        else {
+            this.unshift(track);
         }
-        // Emit an event to update the player state indicating the queue has been shuffled.
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "shuffle",
-            },
-        });
-        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
     }
     /**
-     * Shuffles the queue to play tracks requested by each user one block at a time.
+     * @returns Whether all elements in the queue satisfy the provided testing function.
      */
-    async userBlockShuffle() {
-        // Capture the current state of the player for event emission.
+    async everyAsync(callback) {
+        return this.every(callback);
+    }
+    /**
+     * @returns A new array with all elements that pass the test implemented by the provided function.
+     */
+    async filterAsync(callback) {
+        return this.filter(callback);
+    }
+    /**
+     * @returns The first element in the queue that satisfies the provided testing function.
+     */
+    async findAsync(callback) {
+        return this.find(callback);
+    }
+    /**
+     * @returns The current track.
+     */
+    async getCurrent() {
+        return this.current;
+    }
+    /**
+     * @returns The previous tracks.
+     */
+    async getPrevious() {
+        return [...this.previous];
+    }
+    /**
+     * @returns The tracks in the queue from start to end.
+     */
+    async getSlice(start, end) {
+        return this.slice(start, end); // Native sync method, still wrapped in a Promise
+    }
+    /**
+     * @returns The tracks in the queue.
+     */
+    async getTracks() {
+        return [...this]; // clone to avoid direct mutation
+    }
+    /**
+     * @returns A new array with the results of calling a provided function on every element in the queue.
+     */
+    async mapAsync(callback) {
+        return this.map(callback);
+    }
+    /**
+     * Modifies the queue at the specified index.
+     * @param start The index at which to start modifying the queue.
+     * @param deleteCount The number of elements to remove from the queue.
+     * @param items The elements to add to the queue.
+     * @returns The modified queue.
+     */
+    async modifyAt(start, deleteCount = 0, ...items) {
+        return super.splice(start, deleteCount, ...items);
+    }
+    /**
+     * @returns The newest track.
+     */
+    async popPrevious() {
+        return this.previous.shift() || null; // get newest track
+    }
+    async remove(startOrPosition = 0, end) {
         const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        // Group the tracks in the queue by the user that requested them.
-        const userTracks = new Map();
-        this.forEach((track) => {
-            const user = track.requester.id;
-            if (!userTracks.has(user)) {
-                userTracks.set(user, []);
+        if (typeof end !== "undefined") {
+            // Validate input for `start` and `end`
+            if (isNaN(Number(startOrPosition)) || isNaN(Number(end))) {
+                throw new RangeError(`Invalid "start" or "end" parameter: start = ${startOrPosition}, end = ${end}`);
             }
-            userTracks.get(user).push(track);
-        });
-        // Create a new array for the shuffled queue.
-        const shuffledQueue = [];
-        // Iterate over the user tracks and add one track from each user to the shuffled queue.
-        // This will ensure that all the tracks requested by each user are played in a block order.
-        while (shuffledQueue.length < this.length) {
-            userTracks.forEach((tracks) => {
-                const track = tracks.shift();
-                if (track) {
-                    shuffledQueue.push(track);
-                }
+            if (startOrPosition >= end || startOrPosition >= this.length) {
+                throw new RangeError("Invalid range: start should be less than end and within queue length.");
+            }
+            const removedTracks = this.splice(startOrPosition, end - startOrPosition);
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removedTracks.length} track(s) from player: ${this.guildId} from position ${startOrPosition} to ${end}.`);
+            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "remove",
+                    tracks: removedTracks,
+                },
             });
+            return removedTracks;
         }
-        // Clear the queue and add the shuffled tracks.
-        this.splice(0);
-        this.add(shuffledQueue);
-        // Emit an event to update the player state indicating the queue has been shuffled.
+        // Single item removal when no end specified
+        const removedTrack = this.splice(startOrPosition, 1);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed 1 track from player: ${this.guildId} from position ${startOrPosition}: ${JSON.stringify(removedTrack[0], null, 2)}`);
+        // Ensure removedTrack is an array for consistency
+        const tracksToEmit = removedTrack.length > 0 ? removedTrack : [];
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
             changeType: Enums_1.PlayerStateEventTypes.QueueChange,
             details: {
                 type: "queue",
-                action: "userBlock",
+                action: "remove",
+                tracks: tracksToEmit,
             },
         });
-        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
+        return removedTrack;
     }
     /**
      * Shuffles the queue to play tracks requested by each user one by one.
@@ -350,62 +327,47 @@ class MemoryQueue extends Array {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
     }
     /**
-     * Removes the first element from the queue.
-     */
-    async dequeue() {
-        return super.shift();
-    }
-    /**
-     * Adds the specified track or tracks to the front of the queue.
-     * @param track The track or tracks to add.
-     */
-    async enqueueFront(track) {
-        if (Array.isArray(track)) {
-            this.unshift(...track);
-        }
-        else {
-            this.unshift(track);
-        }
-    }
-    /**
-     * @returns A shallow copy of the queue.
-     */
-    async getTracks() {
-        return [...this]; // clone to avoid direct mutation
-    }
-    /**
-     * @returns A shallow copy of the queue.
-     */
-    async getSlice(start, end) {
-        return this.slice(start, end); // Native sync method, still wrapped in a Promise
-    }
-    /**
-     * Modifies the queue at the specified index.
-     * @param start The index at which to start modifying the queue.
-     * @param deleteCount The number of elements to remove from the queue.
-     * @param items The elements to add to the queue.
-     * @returns The modified queue.
+     * @param track The track to set.
      */
-    async modifyAt(start, deleteCount = 0, ...items) {
-        return super.splice(start, deleteCount, ...items);
+    async setCurrent(track) {
+        this.current = track;
     }
     /**
-     * @returns A new array with the results of calling a provided function on every element in the queue.
+     * @param tracks The tracks to set.
      */
-    async mapAsync(callback) {
-        return this.map(callback);
+    async setPrevious(tracks) {
+        this.previous = [...tracks];
     }
     /**
-     * @returns A new array with all elements that pass the test implemented by the provided function.
+     * Shuffles the queue.
+     * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    async filterAsync(callback) {
-        return this.filter(callback);
+    async shuffle() {
+        // Capture the current state of the player for event emission.
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        // Shuffle the queue.
+        for (let i = this.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [this[i], this[j]] = [this[j], this[i]];
+        }
+        // Emit an event to update the player state indicating the queue has been shuffled.
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "shuffle",
+            },
+        });
+        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
     }
     /**
-     * @returns The first element in the queue that satisfies the provided testing function.
+     * The size of tracks in the queue.
+     * This does not include the currently playing track.
+     * @returns The size of tracks in the queue.
      */
-    async findAsync(callback) {
-        return this.find(callback);
+    async size() {
+        return this.length;
     }
     /**
      * @returns Whether at least one element in the queue satisfies the provided testing function.
@@ -414,10 +376,53 @@ class MemoryQueue extends Array {
         return this.some(callback);
     }
     /**
-     * @returns Whether all elements in the queue satisfy the provided testing function.
+     * The total size of tracks in the queue including the current track.
+     * This includes the current track if it is not null.
+     * @returns The total size of tracks in the queue including the current track.
      */
-    async everyAsync(callback) {
-        return this.every(callback);
+    async totalSize() {
+        return this.length + (this.current ? 1 : 0);
+    }
+    /**
+     * Shuffles the queue to play tracks requested by each user one block at a time.
+     */
+    async userBlockShuffle() {
+        // Capture the current state of the player for event emission.
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        // Group the tracks in the queue by the user that requested them.
+        const userTracks = new Map();
+        this.forEach((track) => {
+            const user = track.requester.id;
+            if (!userTracks.has(user)) {
+                userTracks.set(user, []);
+            }
+            userTracks.get(user).push(track);
+        });
+        // Create a new array for the shuffled queue.
+        const shuffledQueue = [];
+        // Iterate over the user tracks and add one track from each user to the shuffled queue.
+        // This will ensure that all the tracks requested by each user are played in a block order.
+        while (shuffledQueue.length < this.length) {
+            userTracks.forEach((tracks) => {
+                const track = tracks.shift();
+                if (track) {
+                    shuffledQueue.push(track);
+                }
+            });
+        }
+        // Clear the queue and add the shuffled tracks.
+        this.splice(0);
+        this.add(shuffledQueue);
+        // Emit an event to update the player state indicating the queue has been shuffled.
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "userBlock",
+            },
+        });
+        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
     }
 }
 exports.MemoryQueue = MemoryQueue;