magmastream 2.9.2-dev.1 → 2.9.2-dev.10

package/dist/statestorage/MemoryQueue.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryQueue = void 0;
 const Enums_1 = require("../structures/Enums");
 const Utils_1 = require("../structures/Utils");
+const MagmastreamError_1 = require("../structures/MagmastreamError");
 /**
  * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
  */
@@ -34,96 +35,120 @@ class MemoryQueue 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 = isArray ? tracks.map((t) => Utils_1.JSONUtils.safe(t, 2)).join(", ") : Utils_1.JSONUtils.safe(track, 2);
-        // Emit a debug message
-        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 (isArray) {
-                this.current = tracks.shift() || null;
-                this.push(...tracks);
-            }
-            else {
-                this.current = track;
-            }
-        }
-        else {
-            // If an offset is provided, add the track(s) at that position
-            if (typeof offset !== "undefined" && typeof offset === "number") {
-                // Validate the offset
-                if (isNaN(offset)) {
-                    throw new RangeError("Offset must be a number.");
-                }
-                // Make sure the offset is between 0 and the length of the queue
-                if (offset < 0 || offset > this.length) {
-                    throw new RangeError(`Offset must be between 0 and ${this.length}.`);
-                }
-                // Add the track(s) at the offset position
+        try {
+            const isArray = Array.isArray(track);
+            const tracks = isArray ? [...track] : [track];
+            // Get the track info as a string
+            const trackInfo = isArray ? tracks.map((t) => Utils_1.JSONUtils.safe(t, 2)).join(", ") : Utils_1.JSONUtils.safe(track, 2);
+            // Emit a debug message
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MEMORYQUEUE] 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 (isArray) {
-                    this.splice(offset, 0, ...tracks);
+                    this.current = tracks.shift() || null;
+                    this.push(...tracks);
                 }
                 else {
-                    this.splice(offset, 0, track);
+                    this.current = track;
                 }
             }
             else {
-                // If no offset is provided, add the track(s) at the end of the queue
-                if (isArray) {
-                    this.push(...tracks);
+                // If an offset is provided, add the track(s) at that position
+                if (typeof offset !== "undefined" && typeof offset === "number") {
+                    // Validate the offset
+                    if (isNaN(offset)) {
+                        throw new RangeError("Offset must be a number.");
+                    }
+                    // Make sure the offset is between 0 and the length of the queue
+                    if (offset < 0 || offset > this.length) {
+                        throw new RangeError(`Offset must be between 0 and ${this.length}.`);
+                    }
+                    // Add the track(s) at the offset position
+                    if (isArray) {
+                        this.splice(offset, 0, ...tracks);
+                    }
+                    else {
+                        this.splice(offset, 0, track);
+                    }
                 }
                 else {
-                    this.push(track);
+                    // If no offset is provided, add the track(s) at the end of the queue
+                    if (isArray) {
+                        this.push(...tracks);
+                    }
+                    else {
+                        this.push(track);
+                    }
                 }
             }
-        }
-        if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
-            if (!isArray) {
-                const AutoplayUser = this.manager.players.get(this.guildId).get("Internal_AutoplayUser");
-                if (AutoplayUser && AutoplayUser.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;
+            if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
+                if (!isArray) {
+                    const AutoplayUser = this.manager.players.get(this.guildId).get("Internal_AutoplayUser");
+                    if (AutoplayUser && AutoplayUser.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;
+                    }
                 }
             }
+            // Emit a player state update event with the added track(s)
+            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],
+                },
+            });
+        }
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_MEMORY_ERROR,
+                    message: `Failed to add tracks to queue for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
         }
-        // Emit a player state update event with the added track(s)
-        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) {
-        const max = this.manager.options.maxPreviousTracks;
-        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);
+        try {
+            const max = this.manager.options.maxPreviousTracks;
+            if (Array.isArray(track)) {
+                const newTracks = track.filter((t) => !this.previous.some((p) => p.identifier === t.identifier));
+                this.previous.push(...newTracks);
+            }
+            else {
+                const exists = this.previous.some((p) => p.identifier === track.identifier);
+                if (!exists) {
+                    this.previous.push(track);
+                }
+            }
+            if (this.previous.length > max) {
+                this.previous = this.previous.slice(-max);
             }
         }
-        if (this.previous.length > max) {
-            this.previous = this.previous.slice(0, max);
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_MEMORY_ERROR,
+                    message: `Failed to add tracks to previous tracks for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
         }
     }
     /**
@@ -131,21 +156,33 @@ class MemoryQueue extends Array {
      * 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: {
-                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}`);
+        try {
+            // 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: {
+                    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, `[MEMORYQUEUE] Cleared the queue for: ${this.guildId}`);
+        }
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_MEMORY_ERROR,
+                    message: `Failed to clear queue for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
+        }
     }
     /**
      * Clears the previous tracks.
@@ -241,95 +278,119 @@ class MemoryQueue extends Array {
      * @returns The newest track.
      */
     async popPrevious() {
-        return this.previous.shift() || null; // get newest track
+        return this.previous.pop() || null; // get newest track
     }
     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`
-            if (isNaN(Number(startOrPosition)) || isNaN(Number(end))) {
-                throw new RangeError(`Invalid "start" or "end" parameter: start = ${startOrPosition}, end = ${end}`);
-            }
-            if (startOrPosition >= end || startOrPosition >= this.length) {
-                throw new RangeError("Invalid range: start should be less than end and within queue length.");
+        try {
+            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))) {
+                    throw new RangeError(`Invalid "start" or "end" parameter: start = ${startOrPosition}, end = ${end}`);
+                }
+                if (startOrPosition >= end || startOrPosition >= this.length) {
+                    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(Enums_1.ManagerEventTypes.Debug, `[MEMORYQUEUE] 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: {
+                        type: "queue",
+                        action: "remove",
+                        tracks: removedTracks,
+                    },
+                });
+                return removedTracks;
             }
-            const removedTracks = this.splice(startOrPosition, end - startOrPosition);
-            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removedTracks.length} track(s) from player: ${this.guildId} from position ${startOrPosition} to ${end}.`);
+            // Single item removal when no end specified
+            const removedTrack = this.splice(startOrPosition, 1);
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MEMORYQUEUE] Removed 1 track from player: ${this.guildId} from position ${startOrPosition}: ${Utils_1.JSONUtils.safe(removedTrack[0], 2)}`);
+            // Ensure removedTrack is an array for consistency
+            const tracksToEmit = removedTrack.length > 0 ? removedTrack : [];
             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: removedTracks,
+                    tracks: tracksToEmit,
                 },
             });
-            return removedTracks;
+            return removedTrack;
+        }
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_MEMORY_ERROR,
+                    message: `Failed to remove track(s) from queue for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
         }
-        // Single item removal when no end specified
-        const removedTrack = this.splice(startOrPosition, 1);
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed 1 track from player: ${this.guildId} from position ${startOrPosition}: ${Utils_1.JSONUtils.safe(removedTrack[0], 2)}`);
-        // Ensure removedTrack is an array for consistency
-        const tracksToEmit = removedTrack.length > 0 ? removedTrack : [];
-        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: tracksToEmit,
-            },
-        });
-        return removedTrack;
     }
     /**
      * Shuffles the queue to play tracks requested by each user one by one.
      */
     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) => {
-            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());
+        try {
+            // 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) => {
+                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(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "roundRobin",
+                },
+            });
+            // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MEMORYQUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
+        }
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_MEMORY_ERROR,
+                    message: `Failed to shuffle queue for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
         }
-        // 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(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "roundRobin",
-            },
-        });
-        // 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.
@@ -348,23 +409,35 @@ class MemoryQueue extends Array {
      * This will randomize the order of the tracks in the queue and emit a state update event.
      */
     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.
-        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]];
+        try {
+            // 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.
+            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(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "shuffle",
+                },
+            });
+            // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MEMORYQUEUE] Shuffled the queue for: ${this.guildId}`);
+        }
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_MEMORY_ERROR,
+                    message: `Failed to shuffle queue for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
         }
-        // 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: {
-                type: "queue",
-                action: "shuffle",
-            },
-        });
-        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
     }
     /**
      * The size of tracks in the queue.
@@ -392,42 +465,54 @@ class MemoryQueue extends Array {
      * 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 = 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) => {
-            const user = track.requester.id;
-            if (!userTracks.has(user)) {
-                userTracks.set(user, []);
-            }
-            userTracks.get(user).push(track);
-        });
-        // Create a new array for the shuffled queue.
-        const shuffledQueue = [];
-        // Iterate over the user tracks and add one track from each user to the shuffled queue.
-        // This will ensure that all the tracks requested by each user are played in a block order.
-        while (shuffledQueue.length < this.length) {
-            userTracks.forEach((tracks) => {
-                const track = tracks.shift();
-                if (track) {
-                    shuffledQueue.push(track);
+        try {
+            // 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();
+            this.forEach((track) => {
+                const user = track.requester.id;
+                if (!userTracks.has(user)) {
+                    userTracks.set(user, []);
                 }
+                userTracks.get(user).push(track);
             });
+            // Create a new array for the shuffled queue.
+            const shuffledQueue = [];
+            // Iterate over the user tracks and add one track from each user to the shuffled queue.
+            // This will ensure that all the tracks requested by each user are played in a block order.
+            while (shuffledQueue.length < this.length) {
+                userTracks.forEach((tracks) => {
+                    const track = tracks.shift();
+                    if (track) {
+                        shuffledQueue.push(track);
+                    }
+                });
+            }
+            // 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(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "userBlock",
+                },
+            });
+            // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MEMORYQUEUE] userBlockShuffled the queue for: ${this.guildId}`);
+        }
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_MEMORY_ERROR,
+                    message: `Failed to add tracks to queue for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
         }
-        // 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(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "userBlock",
-            },
-        });
-        // Emit a debug message indicating the queue has been shuffled for a specific guild ID.
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
     }
 }
 exports.MemoryQueue = MemoryQueue;