magmastream 2.9.0-dev.1 → 2.9.0-dev.10

package/dist/structures/RedisQueue.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisQueue = void 0;
+const Manager_1 = require("./Manager");
+class RedisQueue {
+    guildId;
+    manager;
+    current = null;
+    previous = [];
+    redis;
+    redisPrefix;
+    constructor(guildId, manager) {
+        this.guildId = guildId;
+        this.manager = manager;
+        this.redis = manager.redis;
+        this.redisPrefix = manager.options.stateStorage.redisConfig.prefix?.endsWith(":")
+            ? manager.options.stateStorage.redisConfig.prefix
+            : `${manager.options.stateStorage.redisConfig.prefix ?? "magmastream"}:`;
+    }
+    get queueKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:tracks`;
+    }
+    get currentKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:current`;
+    }
+    get previousKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:previous`;
+    }
+    // Helper to serialize/deserialize Track
+    serialize(track) {
+        return JSON.stringify(track);
+    }
+    deserialize(data) {
+        return JSON.parse(data);
+    }
+    async getCurrent() {
+        const raw = await this.redis.get(this.currentKey);
+        return raw ? this.deserialize(raw) : null;
+    }
+    async setCurrent(track) {
+        if (track) {
+            await this.redis.set(this.currentKey, this.serialize(track));
+        }
+        else {
+            await this.redis.del(this.currentKey);
+        }
+    }
+    async getPrevious() {
+        const raw = await this.redis.lrange(this.previousKey, 0, -1);
+        return raw.map(this.deserialize);
+    }
+    async addPrevious(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        if (!tracks.length)
+            return;
+        const serialized = tracks.map(this.serialize);
+        if (!serialized.length)
+            return; // avoid lpush with no values
+        await this.redis.lpush(this.previousKey, ...serialized.reverse());
+    }
+    async clearPrevious() {
+        await this.redis.del(this.previousKey);
+    }
+    async add(track, offset) {
+        const isArray = Array.isArray(track);
+        const tracks = isArray ? track : [track];
+        const serialized = tracks.map((t) => this.serialize(t));
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        // If there's no current track, pop one from the list
+        if (!this.current) {
+            const current = serialized.shift();
+            if (current) {
+                await this.redis.set(this.currentKey, current);
+                this.current = this.deserialize(current);
+            }
+        }
+        if (typeof offset === "number" && !isNaN(offset)) {
+            const queue = await this.redis.lrange(this.queueKey, 0, -1);
+            queue.splice(offset, 0, ...serialized);
+            await this.redis.del(this.queueKey);
+            if (queue.length > 0) {
+                await this.redis.rpush(this.queueKey, ...queue);
+            }
+        }
+        else if (serialized.length > 0) {
+            await this.redis.rpush(this.queueKey, ...serialized);
+        }
+        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Added ${tracks.length} track(s) to queue`);
+        if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
+            if (!Array.isArray(track)) {
+                const botUser = (await this.manager.players.get(this.guildId).get("Internal_BotUser"));
+                if (botUser && botUser.id === track.requester.id) {
+                    this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                        changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+                        details: {
+                            changeType: "autoPlayAdd",
+                            tracks: Array.isArray(track) ? track : [track],
+                        },
+                    });
+                    return;
+                }
+            }
+        }
+        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                changeType: "add",
+                tracks,
+            },
+        });
+    }
+    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(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removed.length} track(s) from position ${startOrPos}${end ? ` to ${end}` : ""}`);
+        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                changeType: "remove",
+                tracks: deserialized,
+            },
+        });
+        return deserialized;
+    }
+    async clear() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        await this.redis.del(this.queueKey);
+        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                changeType: "clear",
+                tracks: [],
+            },
+        });
+        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Cleared the queue for: ${this.guildId}`);
+    }
+    async size() {
+        return await this.redis.llen(this.queueKey);
+    }
+    async totalSize() {
+        const size = await this.size();
+        return this.current ? size + 1 : size;
+    }
+    async duration() {
+        const tracks = await this.redis.lrange(this.queueKey, 0, -1);
+        const currentDuration = this.current?.duration || 0;
+        const total = tracks.reduce((acc, raw) => {
+            try {
+                const parsed = this.deserialize(raw);
+                return acc + (parsed.duration || 0);
+            }
+            catch {
+                return acc;
+            }
+        }, currentDuration);
+        return total;
+    }
+    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(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+            details: { changeType: "shuffle" },
+        });
+        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
+    }
+    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);
+        }
+        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(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+            details: { changeType: "userBlock" },
+        });
+        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
+    }
+    async roundRobinShuffle() {
+        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);
+        }
+        // Shuffle each user's tracks
+        for (const tracks of userMap.values()) {
+            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]];
+            }
+        }
+        const users = [...userMap.keys()];
+        const queues = users.map((id) => userMap.get(id));
+        const shuffledQueue = [];
+        while (queues.some((q) => q.length > 0)) {
+            for (const q of queues) {
+                const track = q.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(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Manager_1.PlayerStateEventTypes.QueueChange,
+            details: { changeType: "roundRobin" },
+        });
+        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
+    }
+    async dequeue() {
+        const raw = await this.redis.lpop(this.queueKey);
+        return raw ? this.deserialize(raw) : undefined;
+    }
+    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 getTracks() {
+        const raw = await this.redis.lrange(this.queueKey, 0, -1);
+        return raw.map(this.deserialize);
+    }
+    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 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);
+        }
+        return removed.map(this.deserialize);
+    }
+    async mapAsync(callback) {
+        const tracks = await this.getTracks(); // same as lrange + deserialize
+        return tracks.map(callback);
+    }
+    async filterAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.filter(callback);
+    }
+    async findAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.find(callback);
+    }
+    async someAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.some(callback);
+    }
+    async everyAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.every(callback);
+    }
+}
+exports.RedisQueue = RedisQueue;