magmastream 2.9.0-dev.35 → 2.9.0-dev.37

package/dist/index.js

@@ -6,7 +6,7 @@ tslib_1.__exportStar(require("./structures/Manager"), exports);
 tslib_1.__exportStar(require("./structures/Node"), exports);
 tslib_1.__exportStar(require("./structures/Player"), exports);
 tslib_1.__exportStar(require("./structures/Plugin"), exports);
-tslib_1.__exportStar(require("./structures/Queue"), exports);
+tslib_1.__exportStar(require("./statestorage/MemoryQueue"), exports);
 tslib_1.__exportStar(require("./structures/Rest"), exports);
 tslib_1.__exportStar(require("./structures/Utils"), exports);
 // wrappers
@@ -14,6 +14,11 @@ tslib_1.__exportStar(require("./wrappers/discord.js"), exports);
 tslib_1.__exportStar(require("./wrappers/eris"), exports);
 tslib_1.__exportStar(require("./wrappers/detritus"), exports);
 tslib_1.__exportStar(require("./wrappers/oceanic"), exports);
+tslib_1.__exportStar(require("./wrappers/seyfert"), exports);
 // types
 tslib_1.__exportStar(require("./structures/Types"), exports);
 tslib_1.__exportStar(require("./structures/Enums"), exports);
+// state storage
+tslib_1.__exportStar(require("./statestorage/MemoryQueue"), exports);
+tslib_1.__exportStar(require("./statestorage/JsonQueue"), exports);
+tslib_1.__exportStar(require("./statestorage/RedisQueue"), exports);

package/dist/statestorage/JsonQueue.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonQueue = void 0;
+const tslib_1 = require("tslib");
+const Enums_1 = require("../structures/Enums");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = require("fs");
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+class JsonQueue {
+    guildId;
+    manager;
+    basePath;
+    /**
+     * @param guildId The guild ID.
+     * @param manager The manager.
+     */
+    constructor(guildId, manager) {
+        this.guildId = guildId;
+        this.manager = manager;
+        const base = manager.options.stateStorage?.jsonConfig?.path ?? path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+        this.basePath = path_1.default.join(base, this.guildId);
+    }
+    /**
+     * @returns The queue path.
+     */
+    get queuePath() {
+        return path_1.default.join(this.basePath, "queue.json");
+    }
+    /**
+     * @returns The current path.
+     */
+    get currentPath() {
+        return path_1.default.join(this.basePath, "current.json");
+    }
+    /**
+     * @returns The previous path.
+     */
+    get previousPath() {
+        return path_1.default.join(this.basePath, "previous.json");
+    }
+    /**
+     * Ensures the directory exists.
+     */
+    async ensureDir() {
+        await fs_1.promises.mkdir(this.basePath, { recursive: true });
+    }
+    /**
+     * @returns The queue.
+     */
+    async getQueue() {
+        const data = await this.readJSON(this.queuePath);
+        return Array.isArray(data) ? data : [];
+    }
+    /**
+     * @param queue The queue.
+     */
+    async setQueue(queue) {
+        await this.writeJSON(this.queuePath, queue);
+    }
+    /**
+     * @param filePath The file path.
+     * @returns The JSON data.
+     */
+    async readJSON(filePath) {
+        try {
+            const raw = await fs_1.promises.readFile(filePath, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * @param filePath The file path.
+     * @param data The data to write.
+     */
+    async writeJSON(filePath, data) {
+        await this.ensureDir();
+        await fs_1.promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    /**
+     * @param filePath The file path.
+     */
+    async deleteFile(filePath) {
+        try {
+            await fs_1.promises.unlink(filePath);
+        }
+        catch {
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[JSONQUEUE] Failed to delete file: ${filePath}`);
+        }
+    }
+    /**
+     * @returns The current track.
+     */
+    async getCurrent() {
+        return await this.readJSON(this.currentPath);
+    }
+    /**
+     * @param track The track to set.
+     */
+    async setCurrent(track) {
+        if (track) {
+            await this.writeJSON(this.currentPath, track);
+        }
+        else {
+            await this.deleteFile(this.currentPath);
+        }
+    }
+    /**
+     * @returns The previous tracks.
+     */
+    async getPrevious() {
+        const data = await this.readJSON(this.previousPath);
+        return Array.isArray(data) ? data : [];
+    }
+    /**
+     * @param track The track to add.
+     */
+    async addPrevious(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        if (!tracks.length)
+            return;
+        const current = await this.getPrevious();
+        await this.writeJSON(this.previousPath, [...tracks.reverse(), ...current]);
+    }
+    /**
+     * @param track The track to set.
+     */
+    async setPrevious(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        if (!tracks.length)
+            return;
+        await this.writeJSON(this.previousPath, tracks);
+    }
+    /**
+     * @returns The newest track.
+     */
+    async popPrevious() {
+        const current = await this.getPrevious();
+        if (!current.length)
+            return null;
+        const popped = current.shift();
+        await this.writeJSON(this.previousPath, current);
+        return popped;
+    }
+    /**
+     * Clears the previous tracks.
+     */
+    async clearPrevious() {
+        await this.deleteFile(this.previousPath);
+    }
+    /**
+     * @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 inputTracks = isArray ? track : [track];
+        const tracks = [...inputTracks];
+        const queue = await this.getQueue();
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        // Set first track as current if none is active
+        if (!(await this.getCurrent())) {
+            const current = tracks.shift();
+            if (current) {
+                await this.setCurrent(current);
+            }
+        }
+        if (typeof offset === "number" && !isNaN(offset)) {
+            queue.splice(offset, 0, ...tracks);
+        }
+        else {
+            queue.push(...tracks);
+        }
+        await this.setQueue(queue);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[JSONQUEUE] Added ${tracks.length} track(s) to queue`);
+        if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
+            if (!isArray) {
+                const botUser = (await this.manager.players.get(this.guildId).get("Internal_BotUser"));
+                if (botUser && botUser.id === track.requester.id) {
+                    this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                        changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                        details: {
+                            type: "queue",
+                            action: "autoPlayAdd",
+                            tracks: [track],
+                        },
+                    });
+                    return;
+                }
+            }
+        }
+        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,
+            },
+        });
+    }
+    async remove(startOrPos = 0, end) {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const queue = await this.getQueue();
+        let removed = [];
+        if (typeof end === "number") {
+            if (startOrPos >= end || startOrPos >= queue.length)
+                throw new RangeError("Invalid range.");
+            removed = queue.splice(startOrPos, end - startOrPos);
+        }
+        else {
+            removed = queue.splice(startOrPos, 1);
+        }
+        await this.setQueue(queue);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[JSONQUEUE] 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: removed,
+            },
+        });
+        return removed;
+    }
+    /**
+     * Clears the queue.
+     */
+    async clear() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        await this.deleteFile(this.queuePath);
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "clear",
+                tracks: [],
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[JSONQUEUE] Cleared the queue for: ${this.guildId}`);
+    }
+    /**
+     * @returns The size of the queue.
+     */
+    async size() {
+        const queue = await this.getQueue();
+        return queue.length;
+    }
+    /**
+     * @returns The total size of the queue.
+     */
+    async totalSize() {
+        const size = await this.size();
+        return (await this.getCurrent()) ? size + 1 : size;
+    }
+    /**
+     * @returns The total duration of the queue.
+     */
+    async duration() {
+        const queue = await this.getQueue();
+        const current = await this.getCurrent();
+        const currentDuration = current?.duration || 0;
+        const total = queue.reduce((acc, track) => acc + (track.duration || 0), currentDuration);
+        return total;
+    }
+    /**
+     * Shuffles the queue.
+     */
+    async shuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const queue = await this.getQueue();
+        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.setQueue(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, `[JSONQUEUE] Shuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * Shuffles the queue by user.
+     */
+    async userBlockShuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const queue = await this.getQueue();
+        const userMap = new Map();
+        for (const track of queue) {
+            const userId = track.requester.id;
+            if (!userMap.has(userId))
+                userMap.set(userId, []);
+            userMap.get(userId).push(track);
+        }
+        const shuffledQueue = [];
+        while (shuffledQueue.length < queue.length) {
+            for (const [, tracks] of userMap) {
+                const track = tracks.shift();
+                if (track)
+                    shuffledQueue.push(track);
+            }
+        }
+        await this.setQueue(shuffledQueue);
+        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, `[JSONQUEUE] userBlockShuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * Shuffles the queue by round-robin.
+     */
+    async roundRobinShuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const queue = await this.getQueue();
+        const userMap = new Map();
+        for (const track of queue) {
+            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.setQueue(shuffledQueue);
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "roundRobin",
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[JSONQUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * Removes the first track from the queue.
+     */
+    async dequeue() {
+        const queue = await this.getQueue();
+        const track = queue.shift();
+        await this.setQueue(queue);
+        return track;
+    }
+    /**
+     * Adds a track to the front of the queue.
+     */
+    async enqueueFront(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        const queue = await this.getQueue();
+        await this.setQueue([...tracks.reverse(), ...queue]);
+    }
+    /**
+     * @returns The tracks in the queue.
+     */
+    async getTracks() {
+        return await this.getQueue();
+    }
+    /**
+     * @returns The tracks in the queue from start to end.
+     */
+    async getSlice(start = 0, end = -1) {
+        const queue = await this.getQueue();
+        if (end === -1)
+            return queue.slice(start);
+        return queue.slice(start, end);
+    }
+    /**
+     * Modifies the queue at the specified index.
+     */
+    async modifyAt(start, deleteCount = 0, ...items) {
+        const queue = await this.getQueue();
+        const removed = queue.splice(start, deleteCount, ...items);
+        await this.setQueue(queue);
+        return removed;
+    }
+    /**
+     * Maps the queue to a new array.
+     */
+    async mapAsync(callback) {
+        const queue = await this.getQueue();
+        return queue.map(callback);
+    }
+    /**
+     * Filters the queue.
+     */
+    async filterAsync(callback) {
+        const queue = await this.getQueue();
+        return queue.filter(callback);
+    }
+    /**
+     * Finds the first track in the queue that satisfies the provided testing function.
+     */
+    async findAsync(callback) {
+        const queue = await this.getQueue();
+        return queue.find(callback);
+    }
+    /**
+     * Tests whether at least one element in the queue passes the test implemented by the provided function.
+     */
+    async someAsync(callback) {
+        const queue = await this.getQueue();
+        return queue.some(callback);
+    }
+    /**
+     * Tests whether all elements in the queue pass the test implemented by the provided function.
+     */
+    async everyAsync(callback) {
+        const queue = await this.getQueue();
+        return queue.every(callback);
+    }
+}
+exports.JsonQueue = JsonQueue;

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 Enums_1 = require("./Enums");
+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,12 +26,21 @@ class Queue 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];
     }
@@ -47,12 +56,21 @@ class Queue extends Array {
             }
         }
     }
+    /**
+     * @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 = [];
     }
@@ -86,16 +104,18 @@ class Queue extends Array {
      * @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(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Added ${Array.isArray(track) ? track.length : 1} track(s) to queue: ${trackInfo}`);
+        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;
@@ -113,8 +133,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);
@@ -122,8 +142,8 @@ 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);
@@ -131,7 +151,7 @@ class Queue extends Array {
             }
         }
         if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
-            if (!Array.isArray(track)) {
+            if (!isArray) {
                 const botUser = this.manager.players.get(this.guildId).get("Internal_BotUser");
                 if (botUser && botUser.id === track.requester.id) {
                     this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
@@ -139,7 +159,7 @@ class Queue extends Array {
                         details: {
                             type: "queue",
                             action: "autoPlayAdd",
-                            tracks: Array.isArray(track) ? track : [track],
+                            tracks: [track],
                         },
                     });
                     return;
@@ -152,7 +172,7 @@ class Queue extends Array {
             details: {
                 type: "queue",
                 action: "add",
-                tracks: Array.isArray(track) ? track : [track],
+                tracks: isArray ? tracks : [track],
             },
         });
     }
@@ -329,9 +349,16 @@ class Queue extends Array {
         // 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}`);
     }
+    /**
+     * 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);
@@ -340,29 +367,57 @@ class Queue extends Array {
             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.
+     */
     async modifyAt(start, deleteCount = 0, ...items) {
         return super.splice(start, deleteCount, ...items);
     }
+    /**
+     * @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);
     }
+    /**
+     * @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 Whether at least one element in the queue satisfies the provided testing function.
+     */
     async someAsync(callback) {
         return this.some(callback);
     }
+    /**
+     * @returns Whether all elements in the queue satisfy the provided testing function.
+     */
     async everyAsync(callback) {
         return this.every(callback);
     }
 }
-exports.Queue = Queue;
+exports.MemoryQueue = MemoryQueue;