magmastream 2.9.0-dev.9 → 2.9.1-dev.0

package/dist/{structures/Queue.js → statestorage/MemoryQueue.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
-const Manager_1 = require("./Manager"); // Import Manager to access emit method
+exports.MemoryQueue = void 0;
+const Enums_1 = require("../structures/Enums");
 /**
  * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
  */
-class Queue extends Array {
+class MemoryQueue extends Array {
     /** The current track */
     current = null;
     /** The previous tracks */
@@ -26,67 +26,25 @@ class Queue extends Array {
         /** The guild property. */
         this.guildId = guildId;
     }
-    async getCurrent() {
-        return this.current;
-    }
-    async setCurrent(track) {
-        this.current = track;
-    }
-    async getPrevious() {
-        return this.previous;
-    }
-    async addPrevious(track) {
-        if (Array.isArray(track)) {
-            this.previous.unshift(...track);
-        }
-        else {
-            this.previous.unshift(track);
-        }
-    }
-    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.
      * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
      */
     async add(track, offset) {
+        const isArray = Array.isArray(track);
+        const tracks = isArray ? [...track] : [track];
         // Get the track info as a string
-        const trackInfo = Array.isArray(track) ? track.map((t) => JSON.stringify(t, null, 2)).join(", ") : JSON.stringify(track, null, 2);
+        const trackInfo = isArray ? tracks.map((t) => JSON.stringify(t, null, 2)).join(", ") : JSON.stringify(track, null, 2);
         // Emit a debug message
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Added ${Array.isArray(track) ? track.length : 1} track(s) to queue: ${trackInfo}`);
-        const oldPlayer = (await this.manager.players.get(this.guildId)) ? { ...(await this.manager.players.get(this.guildId)) } : null;
-        // If the track is valid, add it to the queue
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Added ${tracks.length} track(s) to queue: ${trackInfo}`);
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
         // If the queue is empty, set the track as the current track
         if (!this.current) {
-            if (Array.isArray(track)) {
-                this.current = track.shift() || null;
-                this.push(...track);
+            if (isArray) {
+                this.current = tracks.shift() || null;
+                this.push(...tracks);
             }
             else {
                 this.current = track;
@@ -104,8 +62,8 @@ class Queue extends Array {
                     throw new RangeError(`Offset must be between 0 and ${this.length}.`);
                 }
                 // Add the track(s) at the offset position
-                if (Array.isArray(track)) {
-                    this.splice(offset, 0, ...track);
+                if (isArray) {
+                    this.splice(offset, 0, ...tracks);
                 }
                 else {
                     this.splice(offset, 0, track);
@@ -113,23 +71,24 @@ class Queue extends Array {
             }
             else {
                 // If no offset is provided, add the track(s) at the end of the queue
-                if (Array.isArray(track)) {
-                    this.push(...track);
+                if (isArray) {
+                    this.push(...tracks);
                 }
                 else {
                     this.push(track);
                 }
             }
         }
-        if ((await this.manager.players.has(this.guildId)) && (await this.manager.players.get(this.guildId)).isAutoplay) {
-            if (!Array.isArray(track)) {
-                const botUser = (await (await this.manager.players.get(this.guildId)).get("Internal_BotUser"));
+        if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
+            if (!isArray) {
+                const botUser = this.manager.players.get(this.guildId).get("Internal_BotUser");
                 if (botUser && botUser.id === track.requester.id) {
-                    this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-                        changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+                    this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                        changeType: Enums_1.PlayerStateEventTypes.QueueChange,
                         details: {
-                            changeType: "autoPlayAdd",
-                            tracks: Array.isArray(track) ? track : [track],
+                            type: "queue",
+                            action: "autoPlayAdd",
+                            tracks: [track],
                         },
                     });
                     return;
@@ -137,16 +96,150 @@ class Queue extends Array {
             }
         }
         // Emit a player state update event with the added track(s)
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "add",
+                tracks: isArray ? tracks : [track],
+            },
+        });
+    }
+    /**
+     * 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);
+            }
+        }
+    }
+    /**
+     * Clears the queue.
+     * This will remove all tracks from the queue and emit a state update event.
+     */
+    async clear() {
+        // 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;
+        // Remove all items from the queue.
+        this.splice(0);
+        // Emit an event to update the player state indicating the queue has been cleared.
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
             details: {
-                changeType: "add",
-                tracks: Array.isArray(track) ? track : [track],
+                type: "queue",
+                action: "clear",
+                tracks: [], // No tracks are left after clearing
             },
         });
+        // Emit a debug message indicating the queue has been cleared for a specific guild ID.
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Cleared the queue for: ${this.guildId}`);
+    }
+    /**
+     * Clears the previous tracks.
+     */
+    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);
+        }
+    }
+    /**
+     * @returns Whether all elements in the queue satisfy the provided testing function.
+     */
+    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 = (await this.manager.players.get(this.guildId)) ? { ...(await this.manager.players.get(this.guildId)) } : null;
+        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))) {
@@ -156,11 +249,12 @@ class Queue extends Array {
                 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(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removedTracks.length} track(s) from player: ${this.guildId} from position ${startOrPosition} to ${end}.`);
-            this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-                changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+            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: {
-                    changeType: "remove",
+                    type: "queue",
+                    action: "remove",
                     tracks: removedTracks,
                 },
             });
@@ -168,37 +262,81 @@ class Queue extends Array {
         }
         // Single item removal when no end specified
         const removedTrack = this.splice(startOrPosition, 1);
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Removed 1 track from player: ${this.guildId} from position ${startOrPosition}: ${JSON.stringify(removedTrack[0], null, 2)}`);
+        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(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
             details: {
-                changeType: "remove",
+                type: "queue",
+                action: "remove",
                 tracks: tracksToEmit,
             },
         });
         return removedTrack;
     }
     /**
-     * Clears the queue.
-     * This will remove all tracks from the queue and emit a state update event.
+     * Shuffles the queue to play tracks requested by each user one by one.
      */
-    async clear() {
+    async roundRobinShuffle() {
         // Capture the current state of the player for event emission.
-        const oldPlayer = (await this.manager.players.get(this.guildId)) ? { ...(await this.manager.players.get(this.guildId)) } : null;
-        // Remove all items from the queue.
+        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();
+        // Group the tracks in the queue by the user that requested them.
+        this.forEach((track) => {
+            const user = track.requester.id;
+            if (!userTracks.has(user)) {
+                userTracks.set(user, []);
+            }
+            userTracks.get(user).push(track);
+        });
+        // Shuffle the tracks of each user.
+        userTracks.forEach((tracks) => {
+            for (let i = tracks.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [tracks[i], tracks[j]] = [tracks[j], tracks[i]];
+            }
+        });
+        // Create a new array for the shuffled queue.
+        const shuffledQueue = [];
+        // Add the shuffled tracks to the queue in a round-robin fashion.
+        const users = Array.from(userTracks.keys());
+        const userQueues = users.map((user) => userTracks.get(user));
+        const userCount = users.length;
+        while (userQueues.some((queue) => queue.length > 0)) {
+            for (let i = 0; i < userCount; i++) {
+                const queue = userQueues[i];
+                if (queue.length > 0) {
+                    shuffledQueue.push(queue.shift());
+                }
+            }
+        }
+        // Clear the queue and add the shuffled tracks.
         this.splice(0);
-        // Emit an event to update the player state indicating the queue has been cleared.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+        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: {
-                changeType: "clear",
-                tracks: [], // No tracks are left after clearing
+                type: "queue",
+                action: "roundRobin",
             },
         });
-        // Emit a debug message indicating the queue has been cleared for a specific guild ID.
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Cleared the queue for: ${this.guildId}`);
+        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * @param track The track to set.
+     */
+    async setCurrent(track) {
+        this.current = track;
+    }
+    /**
+     * @param tracks The tracks to set.
+     */
+    async setPrevious(tracks) {
+        this.previous = [...tracks];
     }
     /**
      * Shuffles the queue.
@@ -206,28 +344,51 @@ class Queue extends Array {
      */
     async shuffle() {
         // Capture the current state of the player for event emission.
-        const oldPlayer = (await this.manager.players.get(this.guildId)) ? { ...(await this.manager.players.get(this.guildId)) } : null;
+        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(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
             details: {
-                changeType: "shuffle",
+                type: "queue",
+                action: "shuffle",
             },
         });
         // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * @returns Whether at least one element in the queue satisfies the provided testing function.
+     */
+    async someAsync(callback) {
+        return this.some(callback);
+    }
+    /**
+     * 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);
     }
     /**
      * 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 = (await this.manager.players.get(this.guildId)) ? { ...(await this.manager.players.get(this.guildId)) } : null;
+        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) => {
@@ -253,97 +414,15 @@ class Queue extends Array {
         this.splice(0);
         this.add(shuffledQueue);
         // Emit an event to update the player state indicating the queue has been shuffled.
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                changeType: "userBlock",
-            },
-        });
-        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
-    }
-    /**
-     * Shuffles the queue to play tracks requested by each user one by one.
-     */
-    async roundRobinShuffle() {
-        const oldPlayer = (await this.manager.players.get(this.guildId)) ? { ...(await this.manager.players.get(this.guildId)) } : null;
-        const userTracks = new Map();
-        // Group the tracks in the queue by the user that requested them.
-        this.forEach((track) => {
-            const user = track.requester.id;
-            if (!userTracks.has(user)) {
-                userTracks.set(user, []);
-            }
-            userTracks.get(user).push(track);
-        });
-        // Shuffle the tracks of each user.
-        userTracks.forEach((tracks) => {
-            for (let i = tracks.length - 1; i > 0; i--) {
-                const j = Math.floor(Math.random() * (i + 1));
-                [tracks[i], tracks[j]] = [tracks[j], tracks[i]];
-            }
-        });
-        // Create a new array for the shuffled queue.
-        const shuffledQueue = [];
-        // Add the shuffled tracks to the queue in a round-robin fashion.
-        const users = Array.from(userTracks.keys());
-        const userQueues = users.map((user) => userTracks.get(user));
-        const userCount = users.length;
-        while (userQueues.some((queue) => queue.length > 0)) {
-            for (let i = 0; i < userCount; i++) {
-                const queue = userQueues[i];
-                if (queue.length > 0) {
-                    shuffledQueue.push(queue.shift());
-                }
-            }
-        }
-        // 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(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, await this.manager.players.get(this.guildId), {
-            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
             details: {
-                changeType: "roundRobin",
+                type: "queue",
+                action: "userBlock",
             },
         });
         // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
-    }
-    async dequeue() {
-        return super.shift();
-    }
-    async enqueueFront(track) {
-        if (Array.isArray(track)) {
-            this.unshift(...track);
-        }
-        else {
-            this.unshift(track);
-        }
-    }
-    async getTracks() {
-        return [...this]; // clone to avoid direct mutation
-    }
-    async getSlice(start, end) {
-        return this.slice(start, end); // Native sync method, still wrapped in a Promise
-    }
-    async modifyAt(start, deleteCount = 0, ...items) {
-        return super.splice(start, deleteCount, ...items);
-    }
-    async mapAsync(callback) {
-        return this.map(callback);
-    }
-    async filterAsync(callback) {
-        return this.filter(callback);
-    }
-    async findAsync(callback) {
-        return this.find(callback);
-    }
-    async someAsync(callback) {
-        return this.some(callback);
-    }
-    async everyAsync(callback) {
-        return this.every(callback);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
     }
 }
-exports.Queue = Queue;
+exports.MemoryQueue = MemoryQueue;