magmastream 2.9.0-dev.45 → 2.9.0-dev.47

package/dist/statestorage/RedisQueue.js

@@ -8,14 +8,14 @@ const Enums_1 = require("../structures/Enums");
 class RedisQueue {
     guildId;
     manager;
-    /**
-     * The Redis instance.
-     */
-    redis;
     /**
      * The prefix for the Redis keys.
      */
     redisPrefix;
+    /**
+     * The Redis instance.
+     */
+    redis;
     /**
      * Constructs a new RedisQueue.
      * @param guildId The guild ID.
@@ -29,97 +29,9 @@ class RedisQueue {
             ? manager.options.stateStorage.redisConfig.prefix
             : `${manager.options.stateStorage.redisConfig.prefix ?? "magmastream"}:`;
     }
+    // #region Public
     /**
-     * @returns The queue key.
-     */
-    get queueKey() {
-        return `${this.redisPrefix}queue:${this.guildId}:tracks`;
-    }
-    /**
-     * @returns The current key.
-     */
-    get currentKey() {
-        return `${this.redisPrefix}queue:${this.guildId}:current`;
-    }
-    /**
-     * @returns The previous key.
-     */
-    get previousKey() {
-        return `${this.redisPrefix}queue:${this.guildId}:previous`;
-    }
-    /**
-     * Helper to serialize/deserialize Track
-     */
-    serialize(track) {
-        return JSON.stringify(track);
-    }
-    /**
-     * Helper to serialize/deserialize Track
-     */
-    deserialize(data) {
-        return JSON.parse(data);
-    }
-    /**
-     * @returns The current track.
-     */
-    async getCurrent() {
-        const raw = await this.redis.get(this.currentKey);
-        return raw ? this.deserialize(raw) : null;
-    }
-    /**
-     * @param track The track to set.
-     */
-    async setCurrent(track) {
-        if (track) {
-            await this.redis.set(this.currentKey, this.serialize(track));
-        }
-        else {
-            await this.redis.del(this.currentKey);
-        }
-    }
-    /**
-     * @returns The previous tracks.
-     */
-    async getPrevious() {
-        const raw = await this.redis.lrange(this.previousKey, 0, -1);
-        return raw.map(this.deserialize);
-    }
-    /**
-     * @param track The track to add.
-     */
-    async addPrevious(track) {
-        const tracks = Array.isArray(track) ? track : [track];
-        if (!tracks.length)
-            return;
-        const serialized = tracks.map(this.serialize);
-        if (!serialized.length)
-            return;
-        await this.redis.lpush(this.previousKey, ...serialized.reverse());
-    }
-    /**
-     * @param track The track to set.
-     */
-    async setPrevious(track) {
-        const tracks = Array.isArray(track) ? track : [track];
-        if (!tracks.length)
-            return;
-        await this.redis.del(this.previousKey);
-        await this.redis.rpush(this.previousKey, ...tracks.map(this.serialize));
-    }
-    /**
-     * @returns The newest track.
-     */
-    async popPrevious() {
-        const raw = await this.redis.lpop(this.previousKey); // get newest track (index 0)
-        return raw ? this.deserialize(raw) : null;
-    }
-    /**
-     * Clears the previous tracks.
-     */
-    async clearPrevious() {
-        await this.redis.del(this.previousKey);
-    }
-    /**
+     * Adds a track or tracks 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.
      */
@@ -172,35 +84,18 @@ class RedisQueue {
             },
         });
     }
-    async remove(startOrPos = 0, end) {
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        const queue = await this.redis.lrange(this.queueKey, 0, -1);
-        let removed = [];
-        if (typeof end === "number") {
-            if (startOrPos >= end || startOrPos >= queue.length) {
-                throw new RangeError("Invalid range.");
-            }
-            removed = queue.slice(startOrPos, end);
-            queue.splice(startOrPos, end - startOrPos);
-        }
-        else {
-            removed = queue.splice(startOrPos, 1);
-        }
-        await this.redis.del(this.queueKey);
-        if (queue.length > 0) {
-            await this.redis.rpush(this.queueKey, ...queue);
-        }
-        const deserialized = removed.map(this.deserialize);
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removed.length} track(s) from position ${startOrPos}${end ? ` 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: deserialized,
-            },
-        });
-        return deserialized;
+    /**
+     * Adds a track or tracks to the previous tracks.
+     * @param track The track or tracks to add.
+     */
+    async addPrevious(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        if (!tracks.length)
+            return;
+        const serialized = tracks.map(this.serialize);
+        if (!serialized.length)
+            return;
+        await this.redis.lpush(this.previousKey, ...serialized.reverse());
     }
     /**
      * Clears the queue.
@@ -219,17 +114,17 @@ class RedisQueue {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Cleared the queue for: ${this.guildId}`);
     }
     /**
-     * @returns The size of the queue.
+     * Clears the previous tracks.
      */
-    async size() {
-        return await this.redis.llen(this.queueKey);
+    async clearPrevious() {
+        await this.redis.del(this.previousKey);
     }
     /**
-     * @returns The total size of tracks in the queue including the current track.
+     * Removes the first track from the queue.
      */
-    async totalSize() {
-        const size = await this.size();
-        return (await this.getCurrent()) ? size + 1 : size;
+    async dequeue() {
+        const raw = await this.redis.lpop(this.queueKey);
+        return raw ? this.deserialize(raw) : undefined;
     }
     /**
      * @returns The total duration of the queue in milliseconds.
@@ -250,60 +145,130 @@ class RedisQueue {
         return total;
     }
     /**
-     * Shuffles the queue.
+     * Adds a track to the front of the queue.
+     * @param track The track or tracks to add.
      */
-    async shuffle() {
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+    async enqueueFront(track) {
+        const serialized = Array.isArray(track) ? track.map(this.serialize) : [this.serialize(track)];
+        // Redis: LPUSH adds to front, reverse to maintain order if multiple tracks
+        await this.redis.lpush(this.queueKey, ...serialized.reverse());
+    }
+    /**
+     * Whether all tracks in the queue match the specified condition.
+     * @param callback The condition to match.
+     * @returns Whether all tracks in the queue match the specified condition.
+     */
+    async everyAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.every(callback);
+    }
+    /**
+     * Filters the tracks in the queue.
+     * @param callback The condition to match.
+     * @returns The tracks that match the condition.
+     */
+    async filterAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.filter(callback);
+    }
+    /**
+     * Finds the first track in the queue that matches the specified condition.
+     * @param callback The condition to match.
+     * @returns The first track that matches the condition.
+     */
+    async findAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.find(callback);
+    }
+    /**
+     * @returns The current track.
+     */
+    async getCurrent() {
+        const raw = await this.redis.get(this.currentKey);
+        return raw ? this.deserialize(raw) : null;
+    }
+    /**
+     * @returns The previous tracks.
+     */
+    async getPrevious() {
+        const raw = await this.redis.lrange(this.previousKey, 0, -1);
+        return raw.map(this.deserialize);
+    }
+    /**
+     * @returns The tracks in the queue from the start to the end.
+     */
+    async getSlice(start = 0, end = -1) {
+        const raw = await this.redis.lrange(this.queueKey, start, end === -1 ? -1 : end - 1);
+        return raw.map(this.deserialize);
+    }
+    /**
+     * @returns The tracks in the queue.
+     */
+    async getTracks() {
+        const raw = await this.redis.lrange(this.queueKey, 0, -1);
+        return raw.map(this.deserialize);
+    }
+    /**
+     * Maps the tracks in the queue.
+     * @returns The tracks in the queue after the specified index.
+     */
+    async mapAsync(callback) {
+        const tracks = await this.getTracks(); // same as lrange + deserialize
+        return tracks.map(callback);
+    }
+    /**
+     * Modifies the queue at the specified index.
+     * @param start The start index.
+     * @param deleteCount The number of tracks to delete.
+     * @param items The tracks to insert.
+     * @returns The removed tracks.
+     */
+    async modifyAt(start, deleteCount = 0, ...items) {
         const queue = await this.redis.lrange(this.queueKey, 0, -1);
-        for (let i = queue.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [queue[i], queue[j]] = [queue[j], queue[i]];
-        }
+        const removed = queue.splice(start, deleteCount, ...items.map(this.serialize));
         await this.redis.del(this.queueKey);
         if (queue.length > 0) {
             await this.redis.rpush(this.queueKey, ...queue);
         }
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "shuffle",
-            },
-        });
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
+        return removed.map(this.deserialize);
     }
     /**
-     * Shuffles the queue, but keeps the tracks of the same user together.
+     * Removes the newest track.
+     * @returns The newest track.
      */
-    async userBlockShuffle() {
+    async popPrevious() {
+        const raw = await this.redis.lpop(this.previousKey); // get newest track (index 0)
+        return raw ? this.deserialize(raw) : null;
+    }
+    async remove(startOrPos = 0, end) {
         const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
-        const deserialized = rawTracks.map(this.deserialize);
-        const userMap = new Map();
-        for (const track of deserialized) {
-            const userId = track.requester.id;
-            if (!userMap.has(userId))
-                userMap.set(userId, []);
-            userMap.get(userId).push(track);
-        }
-        const shuffledQueue = [];
-        while (shuffledQueue.length < deserialized.length) {
-            for (const [, tracks] of userMap) {
-                const track = tracks.shift();
-                if (track)
-                    shuffledQueue.push(track);
+        const queue = await this.redis.lrange(this.queueKey, 0, -1);
+        let removed = [];
+        if (typeof end === "number") {
+            if (startOrPos >= end || startOrPos >= queue.length) {
+                throw new RangeError("Invalid range.");
             }
+            removed = queue.slice(startOrPos, end);
+            queue.splice(startOrPos, end - startOrPos);
+        }
+        else {
+            removed = queue.splice(startOrPos, 1);
         }
         await this.redis.del(this.queueKey);
-        await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
+        if (queue.length > 0) {
+            await this.redis.rpush(this.queueKey, ...queue);
+        }
+        const deserialized = removed.map(this.deserialize);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removed.length} track(s) from position ${startOrPos}${end ? ` 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: "userBlock",
+                action: "remove",
+                tracks: deserialized,
             },
         });
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
+        return deserialized;
     }
     /**
      * Shuffles the queue round-robin style.
@@ -348,80 +313,135 @@ class RedisQueue {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
     }
     /**
-     * Removes the first track from the queue.
+     * Sets the current track.
+     * @param track The track to set.
      */
-    async dequeue() {
-        const raw = await this.redis.lpop(this.queueKey);
-        return raw ? this.deserialize(raw) : undefined;
+    async setCurrent(track) {
+        if (track) {
+            await this.redis.set(this.currentKey, this.serialize(track));
+        }
+        else {
+            await this.redis.del(this.currentKey);
+        }
     }
     /**
-     * Adds a track to the front of the queue.
+     * Sets the previous track(s).
+     * @param track The track to set.
      */
-    async enqueueFront(track) {
-        const serialized = Array.isArray(track) ? track.map(this.serialize) : [this.serialize(track)];
-        // Redis: LPUSH adds to front, reverse to maintain order if multiple tracks
-        await this.redis.lpush(this.queueKey, ...serialized.reverse());
+    async setPrevious(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        if (!tracks.length)
+            return;
+        await this.redis.del(this.previousKey);
+        await this.redis.rpush(this.previousKey, ...tracks.map(this.serialize));
     }
     /**
-     * @returns The tracks in the queue.
+     * Shuffles the queue.
      */
-    async getTracks() {
-        const raw = await this.redis.lrange(this.queueKey, 0, -1);
-        return raw.map(this.deserialize);
+    async shuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const queue = await this.redis.lrange(this.queueKey, 0, -1);
+        for (let i = queue.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [queue[i], queue[j]] = [queue[j], queue[i]];
+        }
+        await this.redis.del(this.queueKey);
+        if (queue.length > 0) {
+            await this.redis.rpush(this.queueKey, ...queue);
+        }
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "shuffle",
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
     }
     /**
-     * @returns The tracks in the queue from the start to the end.
+     * @returns The size of the queue.
      */
-    async getSlice(start = 0, end = -1) {
-        const raw = await this.redis.lrange(this.queueKey, start, end === -1 ? -1 : end - 1);
-        return raw.map(this.deserialize);
+    async size() {
+        return await this.redis.llen(this.queueKey);
     }
     /**
-     * Modifies the queue at the specified index.
+     * @returns Whether any tracks in the queue match the specified condition.
      */
-    async modifyAt(start, deleteCount = 0, ...items) {
-        const queue = await this.redis.lrange(this.queueKey, 0, -1);
-        const removed = queue.splice(start, deleteCount, ...items.map(this.serialize));
-        await this.redis.del(this.queueKey);
-        if (queue.length > 0) {
-            await this.redis.rpush(this.queueKey, ...queue);
+    async someAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.some(callback);
+    }
+    /**
+     * @returns The total size of tracks in the queue including the current track.
+     */
+    async totalSize() {
+        const size = await this.size();
+        return (await this.getCurrent()) ? size + 1 : size;
+    }
+    /**
+     * Shuffles the queue, but keeps the tracks of the same user together.
+     */
+    async userBlockShuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
+        const deserialized = rawTracks.map(this.deserialize);
+        const userMap = new Map();
+        for (const track of deserialized) {
+            const userId = track.requester.id;
+            if (!userMap.has(userId))
+                userMap.set(userId, []);
+            userMap.get(userId).push(track);
         }
-        return removed.map(this.deserialize);
+        const shuffledQueue = [];
+        while (shuffledQueue.length < deserialized.length) {
+            for (const [, tracks] of userMap) {
+                const track = tracks.shift();
+                if (track)
+                    shuffledQueue.push(track);
+            }
+        }
+        await this.redis.del(this.queueKey);
+        await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "userBlock",
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
     }
+    // #endregion Public
+    // #region Private
     /**
-     * @returns The tracks in the queue after the specified index.
+     * @returns The current key.
      */
-    async mapAsync(callback) {
-        const tracks = await this.getTracks(); // same as lrange + deserialize
-        return tracks.map(callback);
+    get currentKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:current`;
     }
     /**
-     * @returns The tracks in the queue that match the specified condition.
+     * Deserializes a track from a string.
      */
-    async filterAsync(callback) {
-        const tracks = await this.getTracks();
-        return tracks.filter(callback);
+    deserialize(data) {
+        return JSON.parse(data);
     }
     /**
-     * @returns The first track in the queue that matches the specified condition.
+     * @returns The previous key.
      */
-    async findAsync(callback) {
-        const tracks = await this.getTracks();
-        return tracks.find(callback);
+    get previousKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:previous`;
     }
     /**
-     * @returns Whether any tracks in the queue match the specified condition.
+     * @returns The queue key.
      */
-    async someAsync(callback) {
-        const tracks = await this.getTracks();
-        return tracks.some(callback);
+    get queueKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:tracks`;
     }
     /**
-     * @returns Whether all tracks in the queue match the specified condition.
+     * Helper to serialize/deserialize Track
      */
-    async everyAsync(callback) {
-        const tracks = await this.getTracks();
-        return tracks.every(callback);
+    serialize(track) {
+        return JSON.stringify(track);
     }
 }
 exports.RedisQueue = RedisQueue;

package/dist/structures/Enums.js

@@ -89,6 +89,7 @@ var PlayerStateEventTypes;
     PlayerStateEventTypes["ChannelChange"] = "channelChange";
     PlayerStateEventTypes["PlayerCreate"] = "playerCreate";
     PlayerStateEventTypes["PlayerDestroy"] = "playerDestroy";
+    PlayerStateEventTypes["FilterChange"] = "filterChange";
 })(PlayerStateEventTypes || (exports.PlayerStateEventTypes = PlayerStateEventTypes = {}));
 /**
  * Track Source Types Enum