magmastream 2.9.0-dev.2 → 2.9.0-dev.21

package/dist/structures/Queue.js

@@ -6,14 +6,58 @@ const Manager_1 = require("./Manager"); // Import Manager to access emit method
  * 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 {
+    /** The current track */
+    current = null;
+    /** The previous tracks */
+    previous = [];
+    /** The Manager instance. */
+    manager;
+    /** The guild ID property. */
+    guildId;
+    /**
+     * Constructs a new Queue.
+     * @param guildId The guild ID.
+     * @param manager The Manager instance.
+     */
+    constructor(guildId, manager) {
+        super();
+        /** The Manager instance. */
+        this.manager = manager;
+        /** 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 setPrevious(tracks) {
+        this.previous = [...tracks];
+    }
+    async popPrevious() {
+        return this.previous.shift() || null; // get newest track
+    }
+    async clearPrevious() {
+        this.previous = [];
+    }
     /**
      * The total duration of the queue in milliseconds.
      * This includes the duration of the currently playing track.
      */
-    get duration() {
-        // Get the duration of the currently playing track, or 0 if there is none.
+    async duration() {
         const current = this.current?.duration ?? 0;
-        // Return the sum of all durations in the queue including the current track.
         return this.reduce((acc, cur) => acc + (cur.duration || 0), current);
     }
     /**
@@ -21,7 +65,7 @@ class Queue extends Array {
      * This includes the current track if it is not null.
      * @returns The total size of tracks in the queue including the current track.
      */
-    get totalSize() {
+    async totalSize() {
         return this.length + (this.current ? 1 : 0);
     }
     /**
@@ -29,41 +73,20 @@ class Queue extends Array {
      * This does not include the currently playing track.
      * @returns The size of tracks in the queue.
      */
-    get size() {
+    async size() {
         return this.length;
     }
-    /** The current track */
-    current = null;
-    /** The previous tracks */
-    previous = [];
-    /** The Manager instance. */
-    manager;
-    /** The guild ID property. */
-    guildId;
-    /**
-     * Constructs a new Queue.
-     * @param guildId The guild ID.
-     * @param manager The Manager instance.
-     */
-    constructor(guildId, manager) {
-        super();
-        /** The Manager instance. */
-        this.manager = manager;
-        /** The guild property. */
-        this.guildId = guildId;
-    }
     /**
      * 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.
      */
-    add(track, offset) {
+    async add(track, offset) {
         // 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);
         // 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 = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        // If the track is valid, add it to the queue
         // If the queue is empty, set the track as the current track
         if (!this.current) {
             if (Array.isArray(track)) {
@@ -127,7 +150,7 @@ class Queue extends Array {
             },
         });
     }
-    remove(startOrPosition = 0, end) {
+    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`
@@ -166,7 +189,7 @@ class Queue extends Array {
      * Clears the queue.
      * This will remove all tracks from the queue and emit a state update event.
      */
-    clear() {
+    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.
@@ -186,7 +209,7 @@ class Queue extends Array {
      * Shuffles the queue.
      * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    shuffle() {
+    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.
@@ -207,7 +230,7 @@ class Queue extends Array {
     /**
      * Shuffles the queue to play tracks requested by each user one block at a time.
      */
-    userBlockShuffle() {
+    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.
@@ -247,8 +270,10 @@ class Queue extends Array {
     /**
      * Shuffles the queue to play tracks requested by each user one by one.
      */
-    roundRobinShuffle() {
+    async roundRobinShuffle() {
+        // 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();
         // Group the tracks in the queue by the user that requested them.
         this.forEach((track) => {
@@ -292,5 +317,40 @@ class Queue extends Array {
         // 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);
+    }
 }
 exports.Queue = Queue;

package/dist/structures/RedisQueue.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisQueue = void 0;
+const Manager_1 = require("./Manager");
+class RedisQueue {
+    guildId;
+    manager;
+    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;
+        await this.redis.lpush(this.previousKey, ...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));
+    }
+    async popPrevious() {
+        const raw = await this.redis.lpop(this.previousKey); // get newest track (index 0)
+        return raw ? this.deserialize(raw) : null;
+    }
+    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 (!(await this.getCurrent())) {
+            const current = serialized.shift();
+            if (current) {
+                await this.setCurrent(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 (await this.getCurrent()) ? size + 1 : size;
+    }
+    async duration() {
+        const tracks = await this.redis.lrange(this.queueKey, 0, -1);
+        const currentDuration = (await this.getCurrent())?.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;