magmastream 2.9.0-dev.23 → 2.9.0-dev.25

package/dist/index.d.ts

@@ -1528,6 +1528,7 @@ declare class Player {
     autoplayTries: number;
     private static _manager;
     private readonly data;
+    private volumeFadeInProgress;
     private dynamicLoopInterval;
     dynamicRepeatIntervalMs: number | null;
     /**
@@ -1643,14 +1644,16 @@ declare class Player {
     /**
      * Sets the volume of the player.
      * @param {number} volume - The new volume. Must be between 0 and 1000.
+     * @param {GradualOptions} options - The options to use for the gradual change.
      * @returns {Promise<Player>} - The updated player.
      * @throws {TypeError} If the volume is not a number.
      * @throws {RangeError} If the volume is not between 0 and 1000.
      * @emits {PlayerStateUpdate} - Emitted when the volume is changed.
      * @example
      * player.setVolume(50);
+     * player.setVolume(50, { gradual: true, interval: 50, step: 5 });
      */
-    setVolume(volume: number): Promise<this>;
+    setVolume(volume: number, options?: GradualOptions): Promise<this>;
     /**
      * Sets the sponsorblock for the player. This will set the sponsorblock segments for the player to the given segments.
      * @param {SponsorBlockSegment[]} segments - The sponsorblock segments to set. Defaults to `[SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]` if not provided.
@@ -1761,6 +1764,12 @@ declare class Player {
      * @throws {RangeError} - If the 'lavalyrics-plugin' is not available on the Lavalink node.
      */
     getCurrentLyrics(skipTrackSource?: boolean): Promise<Lyrics>;
+    /**
+     * Sleeps for a specified amount of time.
+     * @param ms The amount of time to sleep in milliseconds.
+     * @returns A promise that resolves after the specified amount of time.
+     */
+    private sleep;
 }
 interface PlayerOptions {
     /** The guild ID the Player belongs to. */
@@ -1778,6 +1787,14 @@ interface PlayerOptions {
     /** If the player should deaf itself. */
     selfDeafen?: boolean;
 }
+interface GradualOptions {
+    /** If the change should be gradual. */
+    gradual?: boolean;
+    /** The duration of the gradual change. */
+    interval?: number;
+    /** The step of the gradual change. */
+    step?: number;
+}
 /** If track partials are set some of these will be `undefined` as they were removed. */
 interface Track {
     /** The base64 encoded track. */
@@ -2260,4 +2277,4 @@ declare class Plugin {
 }
 
 export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, Filters, LoadTypes, Manager, ManagerEventTypes, Node, Player, PlayerStateEventTypes, Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
-export type { CPUStats, EqualizerBand, Exception, Extendable, FrameStats, IQueue, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStore, PlayerUpdate, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, State, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent };
+export type { CPUStats, EqualizerBand, Exception, Extendable, FrameStats, GradualOptions, IQueue, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStore, PlayerUpdate, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, State, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent };

package/dist/structures/Manager.js

@@ -246,11 +246,11 @@ class Manager extends events_1.EventEmitter {
      * @returns A promise that resolves when the player has been destroyed.
      */
     async destroy(guildId) {
-        // Emit debug message for player destruction
         this.emit(ManagerEventTypes.Debug, `[MANAGER] Destroying player: ${guildId}`);
-        // Remove the player from the manager's collection
-        this.players.delete(guildId);
-        // Clean up any inactive players
+        const player = this.getPlayer(guildId);
+        if (!player)
+            return;
+        await player.destroy();
         await this.cleanupInactivePlayers();
     }
     /**
@@ -313,13 +313,6 @@ class Manager extends events_1.EventEmitter {
         }
         if (update.user_id !== this.options.clientId)
             return;
-        const missingSessionButHasEvent = !player.voiceState.sessionId && player.voiceState.event;
-        if (missingSessionButHasEvent) {
-            if (player.state !== Utils_1.StateTypes.Destroying && player.state !== Utils_1.StateTypes.Disconnected) {
-                await player.destroy();
-            }
-            return;
-        }
         return await this.handleVoiceStateUpdate(player, update);
     }
     /**

package/dist/structures/Player.js

@@ -54,6 +54,7 @@ class Player {
     autoplayTries = 3;
     static _manager;
     data = {};
+    volumeFadeInProgress = false;
     dynamicLoopInterval = null;
     dynamicRepeatIntervalMs = null;
     /**
@@ -224,10 +225,6 @@ class Player {
      */
     async destroy(disconnect = true) {
         const oldPlayer = this ? { ...this } : null;
-        if (this.state === Utils_1.StateTypes.Destroying || this.state === Utils_1.StateTypes.Disconnected) {
-            console.debug(`[Player#destroy] Already destroying/destroyed for ${this.guildId}`);
-            return false;
-        }
         this.state = Utils_1.StateTypes.Destroying;
         if (disconnect) {
             await this.disconnect().catch((err) => {
@@ -392,30 +389,66 @@ class Player {
     /**
      * Sets the volume of the player.
      * @param {number} volume - The new volume. Must be between 0 and 1000.
+     * @param {GradualOptions} options - The options to use for the gradual change.
      * @returns {Promise<Player>} - The updated player.
      * @throws {TypeError} If the volume is not a number.
      * @throws {RangeError} If the volume is not between 0 and 1000.
      * @emits {PlayerStateUpdate} - Emitted when the volume is changed.
      * @example
      * player.setVolume(50);
+     * player.setVolume(50, { gradual: true, interval: 50, step: 5 });
      */
-    async setVolume(volume) {
+    async setVolume(volume, options) {
         if (isNaN(volume))
             throw new TypeError("Volume must be a number.");
         if (volume < 0 || volume > 1000)
             throw new RangeError("Volume must be between 0 and 1000.");
-        const oldPlayer = this ? { ...this } : null;
-        await this.node.rest.updatePlayer({
-            guildId: this.options.guildId,
-            data: {
-                volume,
-            },
-        });
-        this.volume = volume;
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
-            changeType: Manager_1.PlayerStateEventTypes.VolumeChange,
-            details: { previousVolume: oldPlayer.volume || null, currentVolume: this.volume },
-        });
+        const oldVolume = this.volume;
+        if (options?.gradual) {
+            if (this.volumeFadeInProgress) {
+                throw new Error("A volume fade is already in progress.");
+            }
+            this.volumeFadeInProgress = true;
+            const interval = options.interval ?? 100;
+            const step = options.step ?? 5;
+            const direction = volume > this.volume ? 1 : -1;
+            let currentVolume = this.volume;
+            while (currentVolume !== volume) {
+                currentVolume = direction > 0 ? Math.min(currentVolume + step, volume) : Math.max(currentVolume - step, volume);
+                await this.node.rest.updatePlayer({
+                    guildId: this.options.guildId,
+                    data: { volume: currentVolume },
+                });
+                this.volume = currentVolume;
+                this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, {
+                    changeType: Manager_1.PlayerStateEventTypes.VolumeChange,
+                    details: {
+                        previousVolume: oldVolume,
+                        currentVolume: this.volume,
+                        isGradual: true,
+                    },
+                });
+                if (currentVolume !== volume) {
+                    await this.sleep(interval);
+                }
+            }
+            this.volumeFadeInProgress = false;
+        }
+        else {
+            await this.node.rest.updatePlayer({
+                guildId: this.options.guildId,
+                data: { volume },
+            });
+            this.volume = volume;
+            this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, {
+                changeType: Manager_1.PlayerStateEventTypes.VolumeChange,
+                details: {
+                    previousVolume: oldVolume,
+                    currentVolume: this.volume,
+                    isGradual: false,
+                },
+            });
+        }
         return this;
     }
     /**
@@ -901,5 +934,13 @@ class Player {
         }
         return result;
     }
+    /**
+     * Sleeps for a specified amount of time.
+     * @param ms The amount of time to sleep in milliseconds.
+     * @returns A promise that resolves after the specified amount of time.
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
 }
 exports.Player = Player;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.9.0-dev.23",
+	"version": "2.9.0-dev.25",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",