magmastream 2.9.3-dev.11 → 2.9.3-dev.13

package/dist/index.d.ts

@@ -337,6 +337,10 @@ declare class JsonQueue implements IQueue {
      * The base path for the queue files.
      */
     private basePath;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    private destroyed;
     /**
      * @param guildId The guild ID.
      * @param manager The manager.
@@ -363,6 +367,11 @@ declare class JsonQueue implements IQueue {
      * Removes the first track from the queue.
      */
     dequeue(): Promise<Track | undefined>;
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy(): Promise<void>;
     /**
      * @returns The total duration of the queue.
      */
@@ -502,6 +511,10 @@ declare class MemoryQueue extends Array<Track> implements IQueue {
     manager: Manager;
     /** The guild ID property. */
     guildId: string;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    private destroyed;
     /**
      * Constructs a new Queue.
      * @param guildId The guild ID.
@@ -513,67 +526,72 @@ declare class MemoryQueue extends Array<Track> implements IQueue {
      * @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: Track | Track[], offset?: number): Promise<void>;
+    add(track: Track | Track[], offset?: number): void;
     /**
      * 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.
      */
-    addPrevious(track: Track | Track[]): Promise<void>;
+    addPrevious(track: Track | Track[]): void;
     /**
      * Clears the queue.
      * This will remove all tracks from the queue and emit a state update event.
      */
-    clear(): Promise<void>;
+    clear(): void;
     /**
      * Clears the previous tracks.
      */
-    clearPrevious(): Promise<void>;
+    clearPrevious(): void;
     /**
      * Removes the first element from the queue.
      */
-    dequeue(): Promise<Track | undefined>;
+    dequeue(): Track | undefined;
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy(): void;
     /**
      * The total duration of the queue in milliseconds.
      * This includes the duration of the currently playing track.
      */
-    duration(): Promise<number>;
+    duration(): number;
     /**
      * Adds the specified track or tracks to the front of the queue.
      * @param track The track or tracks to add.
      */
-    enqueueFront(track: Track | Track[]): Promise<void>;
+    enqueueFront(track: Track | Track[]): void;
     /**
      * @returns Whether all elements in the queue satisfy the provided testing function.
      */
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean;
     /**
      * @returns A new array with all elements that pass the test implemented by the provided function.
      */
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track[];
     /**
      * @returns The first element in the queue that satisfies the provided testing function.
      */
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track | undefined;
     /**
      * @returns The current track.
      */
-    getCurrent(): Promise<Track | null>;
+    getCurrent(): Track | null;
     /**
      * @returns The previous tracks.
      */
-    getPrevious(): Promise<Track[]>;
+    getPrevious(): Track[];
     /**
      * @returns The tracks in the queue from start to end.
      */
-    getSlice(start?: number, end?: number): Promise<Track[]>;
+    getSlice(start?: number, end?: number): Track[];
     /**
      * @returns The tracks in the queue.
      */
-    getTracks(): Promise<Track[]>;
+    getTracks(): Track[];
     /**
      * @returns A new array with the results of calling a provided function on every element in the queue.
      */
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): T[];
     /**
      * Modifies the queue at the specified index.
      * @param start The index at which to start modifying the queue.
@@ -581,11 +599,11 @@ declare class MemoryQueue extends Array<Track> implements IQueue {
      * @param items The elements to add to the queue.
      * @returns The modified queue.
      */
-    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Track[];
     /**
      * @returns The newest track.
      */
-    popPrevious(): Promise<Track | null>;
+    popPrevious(): Track | null;
     /**
      * Removes track(s) from the queue.
      * @param startOrPosition If a single number is provided, it will be treated as the position of the track to remove.
@@ -593,45 +611,45 @@ declare class MemoryQueue extends Array<Track> implements IQueue {
      * @param end Optional, end of the range of tracks to remove.
      * @returns The removed track(s).
      */
-    remove(position?: number): Promise<Track[]>;
-    remove(start: number, end: number): Promise<Track[]>;
+    remove(position?: number): Track[];
+    remove(start: number, end: number): Track[];
     /**
      * Shuffles the queue to play tracks requested by each user one by one.
      */
-    roundRobinShuffle(): Promise<void>;
+    roundRobinShuffle(): void;
     /**
      * @param track The track to set.
      */
-    setCurrent(track: Track | null): Promise<void>;
+    setCurrent(track: Track | null): void;
     /**
      * @param tracks The tracks to set.
      */
-    setPrevious(tracks: Track[]): Promise<void>;
+    setPrevious(tracks: Track[]): void;
     /**
      * Shuffles the queue.
      * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    shuffle(): Promise<void>;
+    shuffle(): void;
     /**
      * The size of tracks in the queue.
      * This does not include the currently playing track.
      * @returns The size of tracks in the queue.
      */
-    size(): Promise<number>;
+    size(): number;
     /**
      * @returns Whether at least one element in the queue satisfies the provided testing function.
      */
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean;
     /**
      * The total size of tracks in the queue including the current track.
      * This includes the current track if it is not null.
      * @returns The total size of tracks in the queue including the current track.
      */
-    totalSize(): Promise<number>;
+    totalSize(): number;
     /**
      * Shuffles the queue to play tracks requested by each user one block at a time.
      */
-    userBlockShuffle(): Promise<void>;
+    userBlockShuffle(): void;
 }
 
 /**
@@ -648,6 +666,10 @@ declare class RedisQueue implements IQueue {
      * The Redis instance.
      */
     private redis;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    private destroyed;
     /**
      * Constructs a new RedisQueue.
      * @param guildId The guild ID.
@@ -677,6 +699,11 @@ declare class RedisQueue implements IQueue {
      * Removes the first track from the queue.
      */
     dequeue(): Promise<Track | undefined>;
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy(): Promise<void>;
     /**
      * @returns The total duration of the queue in milliseconds.
      * This includes the duration of the currently playing track.
@@ -1951,33 +1978,34 @@ interface ReverbOptions {
  * Queue interface
  */
 interface IQueue {
-    getCurrent(): Promise<Track | null>;
-    setCurrent(track: Track | null): Promise<void>;
-    getPrevious(): Promise<Track[]>;
-    addPrevious(track: Track | Track[]): Promise<void>;
-    setPrevious(track: Track | Track[]): Promise<void>;
+    getCurrent(): Track | Promise<Track | null>;
+    setCurrent(track: Track | null): void | Promise<void>;
+    getPrevious(): Track[] | Promise<Track[]>;
+    addPrevious(track: Track | Track[]): void | Promise<void>;
+    setPrevious(track: Track | Track[]): void | Promise<void>;
     /** Get newest track (index 0) */
-    popPrevious(): Promise<Track | null>;
-    clearPrevious(): Promise<void>;
-    size(): Promise<number>;
-    totalSize(): Promise<number>;
-    duration(): Promise<number>;
-    add(track: Track | Track[], offset?: number): Promise<void>;
-    remove(start?: number, end?: number): Promise<Track[]>;
-    clear(): Promise<void>;
-    dequeue(): Promise<Track | undefined>;
-    enqueueFront(track: Track | Track[]): Promise<void>;
-    getTracks(): Promise<Track[]>;
-    getSlice(start?: number, end?: number): Promise<Track[]>;
-    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
-    shuffle(): Promise<void>;
-    userBlockShuffle(): Promise<void>;
-    roundRobinShuffle(): Promise<void>;
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    popPrevious(): Track | Promise<Track | null>;
+    clearPrevious(): void | Promise<void>;
+    size(): number | Promise<number>;
+    totalSize(): number | Promise<number>;
+    duration(): number | Promise<number>;
+    add(track: Track | Track[], offset?: number): void | Promise<void>;
+    remove(start?: number, end?: number): Track[] | Promise<Track[]>;
+    clear(): void | Promise<void>;
+    dequeue(): Track | Promise<Track | undefined>;
+    enqueueFront(track: Track | Track[]): void | Promise<void>;
+    getTracks(): Track[] | Promise<Track[]>;
+    getSlice(start?: number, end?: number): Track[] | Promise<Track[]>;
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Track[] | Promise<Track[]>;
+    shuffle(): void | Promise<void>;
+    userBlockShuffle(): void | Promise<void>;
+    roundRobinShuffle(): void | Promise<void>;
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): T[] | Promise<T[]>;
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track[] | Promise<Track[]>;
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track | Promise<Track | undefined>;
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean | Promise<boolean>;
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean | Promise<boolean>;
+    destroy(): void | Promise<void>;
 }
 /**
  * Sizes Enum type

package/dist/statestorage/JsonQueue.js

@@ -17,6 +17,10 @@ class JsonQueue {
      * The base path for the queue files.
      */
     basePath;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    destroyed = false;
     /**
      * @param guildId The guild ID.
      * @param manager The manager.
@@ -172,6 +176,27 @@ class JsonQueue {
             console.error(error);
         }
     }
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        try {
+            await Promise.all([this.deleteFile(this.queuePath), this.deleteFile(this.currentPath), this.deleteFile(this.previousPath)]);
+        }
+        catch (err) {
+            console.error(err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_JSON_ERROR,
+                    message: `Failed to destroy JSONQueue for guild ${this.guildId}`,
+                    cause: err,
+                }));
+        }
+    }
     /**
      * @returns The total duration of the queue.
      */

package/dist/statestorage/MemoryQueue.js

@@ -16,6 +16,10 @@ class MemoryQueue extends Array {
     manager;
     /** The guild ID property. */
     guildId;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    destroyed = false;
     /**
      * Constructs a new Queue.
      * @param guildId The guild ID.
@@ -34,7 +38,7 @@ class MemoryQueue extends Array {
      * @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) {
+    add(track, offset) {
         try {
             const isArray = Array.isArray(track);
             const tracks = isArray ? [...track] : [track];
@@ -122,7 +126,7 @@ class MemoryQueue extends Array {
      * 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) {
+    addPrevious(track) {
         try {
             const max = this.manager.options.maxPreviousTracks;
             if (Array.isArray(track)) {
@@ -154,7 +158,7 @@ class MemoryQueue extends Array {
      * Clears the queue.
      * This will remove all tracks from the queue and emit a state update event.
      */
-    async clear() {
+    clear() {
         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;
@@ -186,20 +190,32 @@ class MemoryQueue extends Array {
     /**
      * Clears the previous tracks.
      */
-    async clearPrevious() {
+    clearPrevious() {
         this.previous = [];
     }
     /**
      * Removes the first element from the queue.
      */
-    async dequeue() {
+    dequeue() {
         return super.shift();
     }
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.splice(0);
+        this.previous.length = 0;
+        this.current = null;
+    }
     /**
      * The total duration of the queue in milliseconds.
      * This includes the duration of the currently playing track.
      */
-    async duration() {
+    duration() {
         const current = this.current?.duration ?? 0;
         return this.reduce((acc, cur) => acc + (cur.duration || 0), current);
     }
@@ -207,7 +223,7 @@ class MemoryQueue extends Array {
      * Adds the specified track or tracks to the front of the queue.
      * @param track The track or tracks to add.
      */
-    async enqueueFront(track) {
+    enqueueFront(track) {
         if (Array.isArray(track)) {
             this.unshift(...track);
         }
@@ -218,49 +234,49 @@ class MemoryQueue extends Array {
     /**
      * @returns Whether all elements in the queue satisfy the provided testing function.
      */
-    async everyAsync(callback) {
+    everyAsync(callback) {
         return this.every(callback);
     }
     /**
      * @returns A new array with all elements that pass the test implemented by the provided function.
      */
-    async filterAsync(callback) {
+    filterAsync(callback) {
         return this.filter(callback);
     }
     /**
      * @returns The first element in the queue that satisfies the provided testing function.
      */
-    async findAsync(callback) {
+    findAsync(callback) {
         return this.find(callback);
     }
     /**
      * @returns The current track.
      */
-    async getCurrent() {
+    getCurrent() {
         return this.current;
     }
     /**
      * @returns The previous tracks.
      */
-    async getPrevious() {
+    getPrevious() {
         return [...this.previous];
     }
     /**
      * @returns The tracks in the queue from start to end.
      */
-    async getSlice(start, end) {
+    getSlice(start, end) {
         return this.slice(start, end); // Native sync method, still wrapped in a Promise
     }
     /**
      * @returns The tracks in the queue.
      */
-    async getTracks() {
+    getTracks() {
         return [...this]; // clone to avoid direct mutation
     }
     /**
      * @returns A new array with the results of calling a provided function on every element in the queue.
      */
-    async mapAsync(callback) {
+    mapAsync(callback) {
         return this.map(callback);
     }
     /**
@@ -270,16 +286,16 @@ class MemoryQueue extends Array {
      * @param items The elements to add to the queue.
      * @returns The modified queue.
      */
-    async modifyAt(start, deleteCount = 0, ...items) {
+    modifyAt(start, deleteCount = 0, ...items) {
         return super.splice(start, deleteCount, ...items);
     }
     /**
      * @returns The newest track.
      */
-    async popPrevious() {
+    popPrevious() {
         return this.previous.pop() || null; // get newest track
     }
-    async remove(startOrPosition = 0, end) {
+    remove(startOrPosition = 0, end) {
         try {
             const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
             if (typeof end !== "undefined") {
@@ -331,7 +347,7 @@ class MemoryQueue extends Array {
     /**
      * Shuffles the queue to play tracks requested by each user one by one.
      */
-    async roundRobinShuffle() {
+    roundRobinShuffle() {
         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;
@@ -394,20 +410,20 @@ class MemoryQueue extends Array {
     /**
      * @param track The track to set.
      */
-    async setCurrent(track) {
+    setCurrent(track) {
         this.current = track;
     }
     /**
      * @param tracks The tracks to set.
      */
-    async setPrevious(tracks) {
+    setPrevious(tracks) {
         this.previous = [...tracks];
     }
     /**
      * Shuffles the queue.
      * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    async shuffle() {
+    shuffle() {
         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;
@@ -443,13 +459,13 @@ class MemoryQueue extends Array {
      * This does not include the currently playing track.
      * @returns The size of tracks in the queue.
      */
-    async size() {
+    size() {
         return this.length;
     }
     /**
      * @returns Whether at least one element in the queue satisfies the provided testing function.
      */
-    async someAsync(callback) {
+    someAsync(callback) {
         return this.some(callback);
     }
     /**
@@ -457,13 +473,13 @@ class MemoryQueue 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.
      */
-    async totalSize() {
+    totalSize() {
         return this.length + (this.current ? 1 : 0);
     }
     /**
      * Shuffles the queue to play tracks requested by each user one block at a time.
      */
-    async userBlockShuffle() {
+    userBlockShuffle() {
         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;

package/dist/statestorage/RedisQueue.js

@@ -18,6 +18,10 @@ class RedisQueue {
      * The Redis instance.
      */
     redis;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    destroyed = false;
     /**
      * Constructs a new RedisQueue.
      * @param guildId The guild ID.
@@ -222,6 +226,28 @@ class RedisQueue {
             console.error(error);
         }
     }
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        try {
+            await this.redis.del(this.queueKey, this.previousKey, this.currentKey);
+        }
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                    message: `Failed to destroy RedisQueue for guild ${this.guildId}: ${err.message}`,
+                    cause: err,
+                });
+            console.error(error);
+        }
+    }
     /**
      * @returns The total duration of the queue in milliseconds.
      * This includes the duration of the currently playing track.

package/dist/structures/Player.js

@@ -273,13 +273,11 @@ class Player {
             this.voiceReceiverWsClient.close();
             this.voiceReceiverWsClient = null;
         }
-        await this.queue.clear();
-        await this.queue.clearPrevious();
-        await this.queue.setCurrent(null);
         if (disconnect) {
             await this.disconnect().catch(() => { });
         }
         await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
+        await this.queue.destroy();
         this.nowPlayingMessage = undefined;
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerDestroy, this);
         const deleted = this.manager.players.delete(this.guildId);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.9.3-dev.11",
+	"version": "2.9.3-dev.13",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -15,7 +15,7 @@
 		"lint": "eslint \"src/**/*.{ts,js}\"",
 		"lint:fix": "eslint --fix \"src/**/*.{ts,js}\"",
 		"ci": "run-s format:check lint build types",
-		"release:dev": "npm run format && npm run lint:fix && npm run ci && npm version prerelease --preid=dev && npm publish --tag dev"
+		"release:dev": "npm run format && npm run lint:fix && npm run ci && npm version prerelease --preid=dev && git push && npm publish --tag dev"
 	},
 	"devDependencies": {
 		"@favware/rollup-type-bundler": "^4.0.0",