aqualink 2.9.13 → 2.10.1

package/build/structures/Player.js

@@ -29,58 +29,55 @@ const FAILURE_REASONS = new Set(['LOAD_FAILED', 'CLEANUP'])
 const RECONNECT_CODES = new Set([4015, 4009, 4006])
 const FAIL_LOAD_TYPES = new Set(['error', 'empty', 'LOAD_FAILED', 'NO_MATCHES'])
 
-const VOLUME_REGEX = /^([0-9]|[1-9][0-9]|1[0-9][0-9]|200)$/
-const POSITION_REGEX = /^\d+$/
+const clamp = v => Math.max(0, Math.min(200, +v || 0))
+const isValidVolume = v => typeof v === 'number' && v >= 0 && v <= 200
+const isValidPosition = p => typeof p === 'number' && !isNaN(p) && p >= 0
+const getRandomIndex = arr => (Math.random() * arr.length) | 0
 
-const _clampVolume = volume => Math.max(0, Math.min(200, volume))
-const _isValidVolume = volume => VOLUME_REGEX.test(String(volume))
-const _isValidPosition = position => POSITION_REGEX.test(String(position))
-
-class OptimizedUpdateBatcher {
+class MicrotaskUpdateBatcher {
   constructor(player) {
     this.player = player
     this.updates = null
-    this.timeoutId = 0
-    this.hasPending = false
+    this.isScheduled = false
   }
 
   batch(data, immediate = false) {
-    if (!this.updates) this.updates = Object.create(null)
-
-    Object.assign(this.updates, data)
-    this.hasPending = true
+    this.updates ??= Object.create(null)
 
-    if (this.timeoutId) {
-      clearTimeout(this.timeoutId)
-      this.timeoutId = 0
+    const keys = Object.keys(data)
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      this.updates[key] = data[key]
     }
 
     if (immediate || data.track) {
       return this._flush()
     }
 
-    this.timeoutId = setTimeout(() => this._flush(), 32)
+    if (!this.isScheduled) {
+      this.isScheduled = true
+      queueMicrotask(() => {
+        this._flush()
+        this.isScheduled = false
+      })
+    }
+
     return Promise.resolve()
   }
 
   _flush() {
-    if (!this.hasPending) return Promise.resolve()
+    if (!this.updates) return
 
     const updates = this.updates
     this.updates = null
-    this.hasPending = false
-    this.timeoutId = 0
-
-    return this.player.updatePlayer(updates)
+    this.player.updatePlayer(updates).catch(err => {
+      console.error('Update player error:', err)
+    })
   }
 
   destroy() {
-    if (this.timeoutId) {
-      clearTimeout(this.timeoutId)
-      this.timeoutId = 0
-    }
     this.updates = null
-    this.hasPending = false
+    this.isScheduled = false
   }
 }
 
@@ -99,9 +96,7 @@ class CircularBuffer {
   }
 
   getLast() {
-    return this.count > 0
-      ? this.buffer[(this.index - 1 + this.size) % this.size]
-      : null
+    return this.count ? this.buffer[(this.index - 1 + this.size) % this.size] : null
   }
 
   clear() {
@@ -115,6 +110,18 @@ class Player extends EventEmitter {
   static EVENT_HANDLERS = EVENT_HANDLERS
   static validModes = VALID_MODES
 
+  playing = false
+  paused = false
+  connected = false
+  isAutoplayEnabled = false
+  isAutoplay = false
+  autoplaySeed = null
+  current = null
+  position = 0
+  timestamp = 0
+  ping = 0
+  nowPlayingMessage = null
+
   constructor(aqua, nodes, options = {}) {
     super()
 
@@ -124,37 +131,19 @@ class Player extends EventEmitter {
     this.textChannel = options.textChannel
     this.voiceChannel = options.voiceChannel
 
-    this.connection = new Connection(this, {
-      sessionId: options.sessionId,
-      token: options.token,
-      endpoint: options.endpoint
-    })
-
+    this.connection = new Connection(this)
     this.filters = new Filters(this)
     this.queue = new Queue()
 
     const vol = options.defaultVolume ?? 100
-    this.volume = _isValidVolume(vol) ? vol : _clampVolume(vol)
+    this.volume = isValidVolume(vol) ? vol : clamp(vol)
 
     this.loop = VALID_MODES.has(options.loop) ? options.loop : LOOP_MODES.NONE
-    this.shouldDeleteMessage = !!this.aqua.options.shouldDeleteMessage
-    this.leaveOnEnd = !!this.aqua.options.leaveOnEnd
+    this.shouldDeleteMessage = !!aqua.options?.shouldDeleteMessage
+    this.leaveOnEnd = !!aqua.options?.leaveOnEnd
 
     this.previousTracks = new CircularBuffer(50)
-
-    this.playing = false
-    this.paused = false
-    this.connected = false
-    this.isAutoplayEnabled = false
-    this.isAutoplay = false
-
-    this.current = null
-    this.position = 0
-    this.timestamp = 0
-    this.ping = 0
-    this.nowPlayingMessage = null
-
-    this._updateBatcher = new OptimizedUpdateBatcher(this)
+    this._updateBatcher = new MicrotaskUpdateBatcher(this)
     this._dataStore = new Map()
 
     this._boundPlayerUpdate = this._handlePlayerUpdate.bind(this)
@@ -165,11 +154,11 @@ class Player extends EventEmitter {
   }
 
   _handlePlayerUpdate(packet) {
-    const { position, connected, ping, time } = packet.state
-    this.position = position
-    this.connected = connected
-    this.ping = ping
-    this.timestamp = time
+    const state = packet.state
+    this.position = state.position
+    this.connected = state.connected
+    this.ping = state.ping
+    this.timestamp = state.time
     this.aqua.emit('playerUpdate', this, packet)
   }
 
@@ -178,7 +167,7 @@ class Player extends EventEmitter {
 
     if (!handlerName || typeof this[handlerName] !== 'function') {
       this.aqua.emit('nodeError', this, new Error(`Unknown event: ${payload.type}`))
-      return;
+      return
     }
 
     try {
@@ -188,76 +177,21 @@ class Player extends EventEmitter {
     }
   }
 
-  get previous() {
-    return this.previousTracks.getLast()
-  }
-
-  get currenttrack() {
-    return this.current
-  }
+  get previous() { return this.previousTracks.getLast() }
+  get currenttrack() { return this.current }
+  getQueue() { return this.queue }
 
   batchUpdatePlayer(data, immediate = false) {
     return this._updateBatcher.batch(data, immediate)
   }
 
-  async autoplay() {
-    if (!this.isAutoplayEnabled || !this.previous) return this
-
-    this.isAutoplay = true
-    const prevInfo = this.previous.info
-    const { sourceName, identifier, uri, requester } = prevInfo
-
-    try {
-      let query = null
-      let source = null
-
-      if (sourceName === 'youtube') {
-        query = `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`
-        source = 'ytmsearch'
-      } else if (sourceName === 'soundcloud') {
-        const scResults = await scAutoPlay(uri)
-        if (!scResults?.length) return this
-        query = scResults[0]
-        source = 'scsearch'
-      } else if (sourceName === 'spotify') {
-        const spResult = await spAutoPlay(identifier)
-        if (!spResult) return this
-        query = `https://open.spotify.com/track/${spResult}`
-        source = 'spotify'
-      } else {
-        return this
-      }
-
-      const response = await this.aqua.resolve({ query, source, requester })
-
-      if (!response?.tracks?.length || FAIL_LOAD_TYPES.has(response.loadType)) {
-        return this.stop()
-      }
-
-      const tracks = response.tracks
-      const track = tracks[Math.floor(Math.random() * tracks.length)]
-
-      if (!track?.info?.title) {
-        throw new Error('Invalid track object')
-      }
-
-      track.requester = this.previous.requester || { id: 'Unknown' }
-      this.queue.push(track)
-      await this.play()
-
-      return this
-    } catch {
-      return this.stop()
-    }
-  }
-
   setAutoplay(enabled) {
     this.isAutoplayEnabled = !!enabled
     return this
   }
 
   async play() {
-    if (!this.connected || !this.queue.length) return;
+    if (!this.connected || !this.queue.length) return
 
     const item = this.queue.shift()
     this.current = item.track ? item : await item.resolve(this.aqua)
@@ -269,7 +203,6 @@ class Player extends EventEmitter {
 
   connect(options = this) {
     const { guildId, voiceChannel, deaf = true, mute = false } = options
-
     this.deaf = deaf
     this.mute = mute
     this.connected = true
@@ -280,45 +213,41 @@ class Player extends EventEmitter {
       self_deaf: deaf,
       self_mute: mute
     })
-
     return this
   }
 
   destroy() {
     if (!this.connected) return this
 
-    this._updateBatcher.destroy()
+    this.connected = false
+    this._updateBatcher?.destroy()
 
     this.send({ guild_id: this.guildId, channel_id: null })
-    this.connected = false
-    this.voiceChannel = null
 
     if (this.nowPlayingMessage) {
-      this.nowPlayingMessage.delete().catch(() => {})
+      this.nowPlayingMessage.delete().catch(() => { })
       this.nowPlayingMessage = null
     }
 
+    this.voiceChannel = null
     this.isAutoplay = false
-    this.aqua.destroyPlayer(this.guildId)
 
+    this.aqua.destroyPlayer(this.guildId)
     if (this.nodes?.connected) {
-      try {
-        this.nodes.rest.destroyPlayer(this.guildId)
-      } catch (error) {
+      this.nodes.rest.destroyPlayer(this.guildId).catch(error => {
         if (!error.message.includes('ECONNREFUSED')) {
-          console.error('Error destroying player:', error)
+          console.error(`[Player ${this.guildId}] Destroy error:`, error.message)
         }
-      }
+      })
     }
 
-    this.previousTracks.clear()
-    this._dataStore.clear()
+    this.previousTracks?.clear()
+    this._dataStore?.clear()
+
     this.removeAllListeners()
 
-    this.queue = null
-    this.previousTracks = null
-    this.connection = null
-    this.filters = null
+    this.queue = this.previousTracks = this.connection = this.filters =
+      this._updateBatcher = this._dataStore = null
 
     return this
   }
@@ -330,44 +259,11 @@ class Player extends EventEmitter {
     return this
   }
 
-  async getLyrics(options = {}) {
-    const { query, useCurrentTrack = true, skipTrackSource = false } = options
-
-    if (query) {
-      return this.nodes.rest.getLyrics({
-        track: { info: { title: query } },
-        skipTrackSource
-      })
-    }
-
-    if (useCurrentTrack && this.playing && this.current?.info) {
-      return this.nodes.rest.getLyrics({
-        track: {
-          info: this.current.info,
-          identifier: this.current.info.identifier,
-          guild_id: this.guildId
-        },
-        skipTrackSource
-      })
-    }
-
-    return null
-  }
-
-  subscribeLiveLyrics() {
-    return this.nodes.rest.subscribeLiveLyrics(this.guildId, false)
-  }
-
-  unsubscribeLiveLyrics() {
-    return this.nodes.rest.unsubscribeLiveLyrics(this.guildId)
-  }
-
   seek(position) {
-    if (!this.playing || !_isValidPosition(position)) return this
+    if (!this.playing || !isValidPosition(position)) return this
 
     const maxPos = this.current?.info?.length
-    this.position = Math.max(0, maxPos ? Math.min(position, maxPos) : position)
-
+    this.position = maxPos ? Math.min(Math.max(0, position), maxPos) : Math.max(0, position)
     this.batchUpdatePlayer({ position: this.position })
     return this
   }
@@ -381,20 +277,16 @@ class Player extends EventEmitter {
   }
 
   setVolume(volume) {
-    if (!_isValidVolume(volume)) return this
-
-    const vol = _clampVolume(volume)
+    if (!isValidVolume(volume)) return this
+    const vol = clamp(volume)
     if (this.volume === vol) return this
-
     this.volume = vol
     this.batchUpdatePlayer({ volume: vol })
     return this
   }
 
   setLoop(mode) {
-    if (!VALID_MODES.has(mode)) {
-      throw new Error('Invalid loop mode')
-    }
+    if (!VALID_MODES.has(mode)) throw new Error('Invalid loop mode')
     this.loop = mode
     this.batchUpdatePlayer({ loop: mode })
     return this
@@ -417,7 +309,6 @@ class Player extends EventEmitter {
       deaf: this.deaf,
       guildId: this.guildId,
       voiceChannel: channel,
-      textChannel: this.textChannel,
       mute: this.mute
     })
     return this
@@ -435,29 +326,125 @@ class Player extends EventEmitter {
     const queue = this.queue
     const len = queue.length
 
-    if (len <= 1) return this
-
     for (let i = len - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1))
-      ;[queue[i], queue[j]] = [queue[j], queue[i]]
+      const j = (Math.random() * (i + 1)) | 0
+        ;[queue[i], queue[j]] = [queue[j], queue[i]]
     }
-
     return this
   }
 
-  getQueue() {
-    return this.queue
-  }
-
-  replay() {
-    return this.seek(0)
-  }
+  replay() { return this.seek(0) }
 
   skip() {
     this.stop()
     return this.playing ? this.play() : undefined
   }
 
+  async getLyrics({ query, useCurrentTrack = true, skipTrackSource = false } = {}) {
+    if (query) {
+      return this.nodes.rest.getLyrics({
+        track: { info: { title: query } },
+        skipTrackSource
+      })
+    }
+
+    if (useCurrentTrack && this.playing && this.current) {
+      const currentInfo = this.current.info
+      return this.nodes.rest.getLyrics({
+        track: {
+          info: currentInfo,
+          encoded: this.current.track,
+          identifier: currentInfo.identifier,
+          guild_id: this.guildId
+        },
+        skipTrackSource
+      })
+    }
+
+    return null
+  }
+
+  subscribeLiveLyrics() {
+    return this.nodes.rest.subscribeLiveLyrics(this.guildId, false)
+  }
+
+  unsubscribeLiveLyrics() {
+    return this.nodes.rest.unsubscribeLiveLyrics(this.guildId)
+  }
+
+  async autoplay() {
+    if (!this.isAutoplayEnabled || !this.previous) return this
+
+    this.isAutoplay = true
+    const prevInfo = this.previous.info
+    const sourceName = prevInfo.sourceName
+    const identifier = prevInfo.identifier
+    const uri = prevInfo.uri
+    const requester = prevInfo.requester
+    const author = prevInfo.author
+
+    try {
+      let query = null
+      let source = null
+      let resolved = null
+      let track = null
+
+      if (sourceName === 'youtube') {
+        query = `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`
+        source = 'ytmsearch'
+      } else if (sourceName === 'soundcloud') {
+        const scResults = await scAutoPlay(uri)
+        if (!scResults?.length) return this
+        query = scResults[0]
+        source = 'scsearch'
+      } else if (sourceName === 'spotify') {
+        this.previousIdentifiers ??= []
+
+        if (this.previous) {
+          this.previousIdentifiers.unshift(this.previous.identifier)
+          if (this.previousIdentifiers.length >= 20) this.previousIdentifiers.pop()
+        }
+
+        if (!this.autoplaySeed) {
+          this.autoplaySeed = {
+            trackId: identifier,
+            artistIds: Array.isArray(author) ? author.join(',') : author
+          }
+        }
+
+        resolved = await spAutoPlay(
+          this.autoplaySeed,
+          this,
+          requester,
+          this.previousIdentifiers
+        )
+        if (!resolved?.length) return this
+      } else {
+        return this
+      }
+
+      if (resolved) {
+        track = resolved[getRandomIndex(resolved)]
+      } else {
+        const response = await this.aqua.resolve({ query, source, requester })
+        if (!response?.tracks?.length || FAIL_LOAD_TYPES.has(response.loadType)) {
+          return this.stop()
+        }
+        track = response.tracks[getRandomIndex(response.tracks)]
+      }
+
+      if (!track?.info?.title) throw new Error('Invalid track object')
+
+      track.requester = this.previous.requester || { id: 'Unknown' }
+      this.queue.push(track)
+      await this.play()
+      return this
+    } catch (err) {
+      console.error('Autoplay failed:', err)
+      return this.stop()
+    }
+  }
+
   async trackStart(player, track) {
     this.playing = true
     this.paused = false
@@ -465,26 +452,24 @@ class Player extends EventEmitter {
   }
 
   async trackEnd(player, track, payload) {
-    if (track) {
-      this.previousTracks.push(track)
-    }
+    if (track) this.previousTracks.push(track)
 
     if (this.shouldDeleteMessage && this.nowPlayingMessage) {
-      this.nowPlayingMessage.delete().catch(() => {})
+      this.nowPlayingMessage.delete().catch(() => { })
       this.nowPlayingMessage = null
     }
 
-    const { reason } = payload
+    const reason = payload.reason
+
     if (FAILURE_REASONS.has(reason)) {
-      if (this.queue.length === 0) {
-        this.previousTracks.clear()
-        this._dataStore.clear()
+      if (!this.queue.length) {
+        this.clearData()
         this.aqua.emit('queueEnd', player)
       } else {
         this.aqua.emit('trackEnd', player, track, reason)
         await player.play()
       }
-      return;
+      return
     }
 
     if (this.loop === LOOP_MODES.TRACK) {
@@ -499,8 +484,7 @@ class Player extends EventEmitter {
       } else {
         this.playing = false
         if (this.leaveOnEnd) {
-          this.previousTracks.clear()
-          this._dataStore.clear()
+          this.clearData()
           this.destroy()
         }
         this.aqua.emit('queueEnd', player)
@@ -522,100 +506,105 @@ class Player extends EventEmitter {
   }
 
   async socketClosed(player, track, payload) {
-    const { code, guildId } = payload || {}
+    if (payload.code === 4014) return this.destroy()
 
-    if (RECONNECT_CODES.has(code)) {
+    if (payload.code === 4015) {
       try {
-        const voiceChannelId = this.voiceChannel?.id || this.voiceChannel
-        const textChannelId = this.textChannel?.id || this.textChannel
-        const currentTrack = this.current
-
-        const savedConnectionState = {
-          sessionId: this.connection?.sessionId,
-          endpoint: this.connection?.endpoint,
-          token: this.connection?.token,
-          region: this.connection?.region,
-          volume: this.volume,
-          position: this.position,
-          paused: this.paused,
-          loop: this.loop,
-          isAutoplayEnabled: this.isAutoplayEnabled
-        }
-
-        if (!voiceChannelId) {
-          this.aqua.emit('socketClosed', player, payload)
+        if (this.connection) {
+          this.connection._updatePlayerVoiceData(true);
+          this.aqua.emit('debug', `[Player ${this.guildId}] Attempting resume...`);
           return;
         }
+      } catch (error) {
+        console.error('Resume failed, falling back to reconnect', error);
+      }
+    }
 
-        if (!player.destroyed) {
-          await player.destroy()
-          this.aqua.emit('playerDestroy', player)
-        }
+    if (!RECONNECT_CODES.has(payload.code)) {
+      this.aqua.emit('socketClosed', player, payload)
+      return
+    }
 
-        const newPlayer = await this.aqua.createConnection({
-          guildId,
-          voiceChannel: voiceChannelId,
-          textChannel: textChannelId,
-          deaf: this.deaf,
-          mute: this.mute,
-          defaultVolume: savedConnectionState.volume,
-          sessionId: savedConnectionState.sessionId,
-          token: savedConnectionState.token,
-          endpoint: savedConnectionState.endpoint
-        })
-
-        if (newPlayer) {
-          newPlayer.loop = savedConnectionState.loop
-          newPlayer.isAutoplayEnabled = savedConnectionState.isAutoplayEnabled
-
-          if (savedConnectionState.sessionId && newPlayer.connection) {
-            Object.assign(newPlayer.connection, {
-              sessionId: savedConnectionState.sessionId,
-              endpoint: savedConnectionState.endpoint,
-              token: savedConnectionState.token,
-              region: savedConnectionState.region
-            })
-          }
+    try {
+      const voiceChannelId = this.voiceChannel?.id || this.voiceChannel
+      if (!voiceChannelId) {
+        this.aqua.emit('socketClosed', player, payload)
+        return
+      }
 
-          if (currentTrack) {
-            newPlayer.queue.add(currentTrack)
+      const connection = this.connection
+      const savedState = {
+        sessionId: connection?.sessionId,
+        endpoint: connection?.endpoint,
+        token: connection?.token,
+        region: connection?.region,
+        volume: this.volume,
+        position: this.position,
+        paused: this.paused,
+        loop: this.loop,
+        isAutoplayEnabled: this.isAutoplayEnabled,
+        currentTrack: this.current,
+        queue: [...this.queue]
+      }
 
-            if (this.queue?.length > 0) {
-              this.queue.forEach(item => newPlayer.queue.add(item))
-            }
+      if (!player.destroyed) {
+        await player.destroy()
+        this.aqua.emit('playerDestroy', player)
+      }
 
-            await newPlayer.play()
+      const newPlayer = await this.aqua.createConnection({
+        guildId: payload.guildId,
+        voiceChannel: voiceChannelId,
+        textChannel: this.textChannel?.id || this.textChannel,
+        deaf: this.deaf,
+        mute: this.mute,
+        defaultVolume: savedState.volume,
+      })
 
-            if (savedConnectionState.position > 5000) {
-              setTimeout(() => {
-                newPlayer.seek(savedConnectionState.position)
-              }, 1000)
-            }
+      if (!newPlayer) throw new Error('Failed to create a new player during reconnection.')
 
-            if (savedConnectionState.paused) {
-              setTimeout(() => {
-                newPlayer.pause(true)
-              }, 1500)
-            }
-          }
+      newPlayer.loop = savedState.loop
+      newPlayer.isAutoplayEnabled = savedState.isAutoplayEnabled
 
-          this.aqua.emit('playerReconnected', newPlayer, {
-            oldPlayer: player,
-            code,
-            restoredState: savedConnectionState
-          })
+      if (savedState.sessionId && newPlayer.connection) {
+        const newConnection = newPlayer.connection
+        newConnection.sessionId = savedState.sessionId
+        newConnection.endpoint = savedState.endpoint
+        newConnection.token = savedState.token
+        newConnection.region = savedState.region
+      }
+
+      if (savedState.currentTrack) {
+        newPlayer.queue.add(savedState.currentTrack)
+        const queue = savedState.queue
+        for (let i = 0; i < queue.length; i++) {
+          newPlayer.queue.add(queue[i])
         }
 
-        return;
-      } catch (error) {
-        console.error('Reconnection failed:', error)
-        this.aqua.emit('socketClosed', player, payload)
-        this.aqua.emit('reconnectionFailed', player, { error, code, payload })
+        await newPlayer.play()
+
+        if (savedState.position > 5000) {
+          setTimeout(() => newPlayer.seek(savedState.position), 1000)
+        }
+
+        if (savedState.paused) {
+          setTimeout(() => newPlayer.pause(true), 1500)
+        }
       }
-      return;
-    }
 
-    this.aqua.emit('socketClosed', player, payload)
+      this.aqua.emit('playerReconnected', newPlayer, {
+        oldPlayer: player,
+        restoredState: savedState
+      })
+    } catch (error) {
+      console.error('Reconnection failed:', error)
+      this.aqua.emit('reconnectionFailed', player, {
+        error,
+        code: payload.code,
+        payload
+      })
+      this.aqua.emit('socketClosed', player, payload)
+    }
   }
 
   async lyricsLine(player, track, payload) {
@@ -630,21 +619,13 @@ class Player extends EventEmitter {
     this.aqua.emit('lyricsNotFound', player, track, payload)
   }
 
-  send(data) {
-    this.aqua.send({ op: 4, d: data })
-  }
-
-  set(key, value) {
-    this._dataStore.set(key, value)
-  }
-
-  get(key) {
-    return this._dataStore.get(key)
-  }
+  send(data) { this.aqua.send({ op: 4, d: data }) }
+  set(key, value) { this._dataStore.set(key, value) }
+  get(key) { return this._dataStore.get(key) }
 
   clearData() {
-    this.previousTracks.clear()
-    this._dataStore.clear()
+    this.previousTracks?.clear()
+    this._dataStore?.clear()
     return this
   }
 
@@ -653,9 +634,7 @@ class Player extends EventEmitter {
   }
 
   async cleanup() {
-    if (!this.playing && !this.paused && this.queue.isEmpty()) {
-      this.destroy()
-    }
+    if (!this.playing && !this.paused && this.queue.isEmpty()) this.destroy()
   }
 }