aqualink 2.9.13 → 2.10.0

package/build/structures/Connection.js

@@ -1,130 +1,133 @@
 'use strict'
 
-const LEGACY_ENDPOINT_REGEX = /^([a-z\-]+)\d+/i
-const MODERN_ENDPOINT_REGEX = /^([a-z\-]+)-\d+\.discord\.media(?::\d+)?$/i
+const ENDPOINT_REGEX = /^([a-z-]+)(?:-\d+\.discord\.media(?::\d+)?|\d+)/i
 
 class Connection {
   constructor(player) {
-    this.player = player
-    this.voiceChannel = player.voiceChannel
-    this.guildId = player.guildId
-    this.aqua = player.aqua
-    this.nodes = player.nodes
+    this._player = player
+    this._aqua = player.aqua
+    this._nodes = player.nodes
+    this._guildId = player.guildId
 
+    this.voiceChannel = player.voiceChannel
     this.sessionId = null
     this.endpoint = null
     this.token = null
     this.region = null
+
+    this.sequence = 0
+    this._lastEndpoint = null
   }
 
-  _extractRegionFromEndpoint(endpoint) {
-    if (!endpoint) return null
+  _extractRegion(endpoint) {
+    const match = endpoint?.match(ENDPOINT_REGEX)
+    return match?.[1] || null
+  }
 
-    const modernMatch = endpoint.match(MODERN_ENDPOINT_REGEX)
-    if (modernMatch) return modernMatch[1]
+  setServerUpdate(data) {
+    if (!data?.endpoint || !data?.token) return
 
-    const legacyMatch = endpoint.match(LEGACY_ENDPOINT_REGEX)
-    if (legacyMatch) return legacyMatch[1]
+    const newEndpoint = data.endpoint.trim()
+    const newRegion = this._extractRegion(newEndpoint)
+    const regionChanged = this.region !== newRegion
+    const endpointChanged = this._lastEndpoint !== newEndpoint
 
-    this.aqua.emit('debug', `[Player ${this.guildId}] Failed to parse endpoint: ${endpoint}`)
-    return 'unknown'
-  }
+    if (regionChanged || endpointChanged) {
+      if (regionChanged && this._aqua.listenerCount('debug') > 0) {
+        this._aqua.emit('debug', `[Player ${this._guildId}] Region: ${this.region || 'none'} → ${newRegion}`)
+      }
 
-  setServerUpdate(data) {
-    if (!data?.endpoint || !data?.token) {
-      this.aqua.emit('debug', `[Player ${this.guildId}] Incomplete server update`)
-      return
-    }
+      if (endpointChanged) {
+        this.sequence = 0
+        this._lastEndpoint = newEndpoint
+      }
 
-    const fullEndpoint = data.endpoint.trim()
-    const newRegion = this._extractRegionFromEndpoint(fullEndpoint)
+      this.endpoint = newEndpoint
+      this.region = newRegion
+    }
 
-    const oldRegion = this.region
-    this.endpoint = fullEndpoint
     this.token = data.token
-    this.region = newRegion
 
-    this.aqua.emit('debug', `[Player ${this.guildId}] Voice server updated: ${oldRegion ? `${oldRegion} → ${newRegion}` : newRegion}, endpoint: ${fullEndpoint}`)
+    if (this._player.paused) {
+      this._player.paused = false
+    }
 
-    if (this.player.paused) this.player.paused = false
-    this._updatePlayerVoiceData()
+    this._updateVoiceData()
   }
 
   setStateUpdate(data) {
-    if (!data || data.user_id !== this.aqua.clientId) return
-
-    const sessionId = data.session_id
-    const channelId = data.channel_id
-    const selfDeaf = data.self_deaf
-    const selfMute = data.self_mute
-
-    if (channelId) {
-      if (this.voiceChannel !== channelId) {
-        this.aqua.emit('playerMove', this.voiceChannel, channelId)
-        this.voiceChannel = channelId
-        this.player.voiceChannel = channelId
+    if (!data || data.user_id !== this._aqua.clientId) return
+
+    const { session_id, channel_id, self_deaf, self_mute } = data
+
+    if (channel_id) {
+      if (this.voiceChannel !== channel_id) {
+        if (this._aqua.listenerCount('playerMove') > 0) {
+          this._aqua.emit('playerMove', this.voiceChannel, channel_id)
+        }
+        this.voiceChannel = channel_id
+        this._player.voiceChannel = channel_id
+      }
+
+      if (this.sessionId !== session_id) {
+        this.sessionId = session_id
       }
 
-      this.player.self_deaf = !!selfDeaf
-      this.player.self_mute = !!selfMute
-      this.sessionId = sessionId
-      this.voiceChannel = channelId
+      this._player.self_deaf = !!self_deaf
+      this._player.self_mute = !!self_mute
+      this._player.connected = true
 
-      this.aqua.emit('debug', `[Player ${this.guildId}] Voice state updated - session: ${sessionId}, channel: ${channelId}`)
-      this.player.connected = true
+      this._updateVoiceData()
     } else {
-      this.aqua.emit('debug', `[Player ${this.guildId}] Voice state updated - disconnected`)
-      if (this.player) {
-        this._destroyPlayer()
-        this.voiceChannel = null;
-        this.player.voiceChannel = null;
-        this.aqua.emit('playerDestroy', this.player)
-      } else {
-        this.aqua.destroyPlayer(this.guildId)
-        this.voiceChannel = null;
-        this.player.voiceChannel = null;
-        this.aqua.emit('playerDestroy', this.player)
-      }
+      this._handleDisconnect()
     }
   }
 
-  _destroyPlayer() {
-    this.aqua.emit('debug', `[Player ${this.guildId}] Destroying player due to voice disconnect`)
-    this.player.destroy()
-    this.aqua.emit('playerDestroy', this.player)
+  _handleDisconnect() {
+    if (!this._player.connected) return
+
+    this._aqua.emit('debug', `[Player ${this._guildId}] Disconnected`)
+
+    this.voiceChannel = null
+    this.sessionId = null
+    this.sequence = 0
+
+    this._player.destroy()
   }
 
-  _updatePlayerVoiceData() {
-    if (!this.sessionId || !this.endpoint || !this.token) {
-      this.aqua.emit('debug', `[Player ${this.guildId}] Incomplete voice data, waiting... (session: ${!!this.sessionId}, endpoint: ${!!this.endpoint}, token: ${!!this.token})`)
-      return
-    }
+  updateSequence(seq) {
+    this.sequence = seq > this.sequence ? seq : this.sequence
+  }
 
-    this.aqua.emit('debug', `[Player ${this.guildId}] Updating player voice data with endpoint: ${this.endpoint}`)
-
-    try {
-      this.nodes.rest.updatePlayer({
-        guildId: this.guildId,
-        data: {
-          voice: {
-            token: this.token,
-            endpoint: this.endpoint,
-            sessionId: this.sessionId
-          },
-          volume: this.player.volume
-        }
-      })
-    } catch (error) {
-      this.aqua.emit('debug', 'updatePlayer', {
-        error: error.message,
-        guildId: this.guildId,
+  _updateVoiceData(isResume = false) {
+    if (!this.sessionId || !this.endpoint || !this.token) return
+
+    const payload = {
+      guildId: this._guildId,
+      data: {
         voice: {
           token: this.token,
           endpoint: this.endpoint,
           sessionId: this.sessionId
-        }
-      })
+        },
+        volume: this._player.volume
+      }
+    }
+
+    if (isResume) {
+      payload.data.voice.resume = true
+      payload.data.voice.sequence = this.sequence
     }
+
+    setImmediate(() => {
+      try {
+        this._nodes.rest.updatePlayer(payload)
+      } catch (error) {
+        if (!error.message.includes('ECONNREFUSED')) {
+          this._aqua.emit('debug', `[Player ${this._guildId}] Update failed: ${error.message}`)
+        }
+      }
+    })
   }
 }
 

package/build/structures/Filters.js

@@ -1,171 +1,182 @@
-"use strict";
+'use strict'
 
 class Filters {
-    constructor(player, options = {}) {
-        this.player = player;
-        
-        this.defaults = {
-            karaoke: { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 },
-            timescale: { speed: 1.0, pitch: 1.0, rate: 1.0 },
-            tremolo: { frequency: 2.0, depth: 0.5 },
-            vibrato: { frequency: 2.0, depth: 0.5 },
-            rotation: { rotationHz: 0.0 },
-            distortion: { sinOffset: 0.0, sinScale: 1.0, cosOffset: 0.0, cosScale: 1.0, tanOffset: 0.0, tanScale: 1.0, offset: 0.0, scale: 1.0 },
-            channelMix: { leftToLeft: 1.0, leftToRight: 0.0, rightToLeft: 0.0, rightToRight: 1.0 },
-            lowPass: { smoothing: 20.0 }
-        };
-        
-        this.filters = {
-            volume: options.volume || 1,
-            equalizer: options.equalizer || [],
-            karaoke: options.karaoke || null,
-            timescale: options.timescale || null,
-            tremolo: options.tremolo || null,
-            vibrato: options.vibrato || null,
-            rotation: options.rotation || null,
-            distortion: options.distortion || null,
-            channelMix: options.channelMix || null,
-            lowPass: options.lowPass || null
-        };
-        
-        this.presets = {
-            bassboost: options.bassboost !== undefined ? options.bassboost : null,
-            slowmode: options.slowmode !== undefined ? options.slowmode : null,
-            nightcore: options.nightcore !== undefined ? options.nightcore : null,
-            vaporwave: options.vaporwave !== undefined ? options.vaporwave : null,
-            _8d: options._8d !== undefined ? options._8d : null
-        };
-        
-        this._pendingUpdate = false;
-        this._updateTimeout = null;
-    }
-
-    _setFilter(filterName, enabled, options = {}, defaultKey = filterName) {
-        this.filters[filterName] = enabled ? { ...this.defaults[defaultKey], ...options } : null;
-        return this._scheduleUpdate();
-    }
-
-    _scheduleUpdate() {
-        this._pendingUpdate = true;
-        
-        if (this._updateTimeout) {
-            clearTimeout(this._updateTimeout);
-        }
-        
-        this._updateTimeout = setTimeout(() => this.updateFilters(), 0);
-        return this;
-    }
-
-    setEqualizer(bands) {
-        this.filters.equalizer = bands || [];
-        return this._scheduleUpdate();
-    }
-
-    setKaraoke(enabled, options = {}) {
-        return this._setFilter('karaoke', enabled, options);
-    }
-
-    setTimescale(enabled, options = {}) {
-        return this._setFilter('timescale', enabled, options);
-    }
-
-    setTremolo(enabled, options = {}) {
-        return this._setFilter('tremolo', enabled, options);
-    }
-
-    setVibrato(enabled, options = {}) {
-        return this._setFilter('vibrato', enabled, options);
-    }
-
-    setRotation(enabled, options = {}) {
-        return this._setFilter('rotation', enabled, options);
-    }
-
-    setDistortion(enabled, options = {}) {
-        return this._setFilter('distortion', enabled, options);
-    }
-
-    setChannelMix(enabled, options = {}) {
-        return this._setFilter('channelMix', enabled, options);
-    }
-
-    setLowPass(enabled, options = {}) {
-        return this._setFilter('lowPass', enabled, options);
-    }
-
-    setBassboost(enabled, options = {}) {
-        if (!enabled) {
-            this.presets.bassboost = null;
-            return this.setEqualizer([]);
-        }
-        
-        const value = options.value || 5;
-        if (value < 0 || value > 5) throw new Error("Bassboost value must be between 0 and 5");
-        
-        this.presets.bassboost = value;
-        const gain = (value - 1) * (1.25 / 9) - 0.25;
-        
-        const eq = Array.from({ length: 13 }, (_, i) => ({ band: i, gain }));
-        
-        return this.setEqualizer(eq);
-    }
-
-    setSlowmode(enabled, options = {}) {
-        this.presets.slowmode = enabled;
-        return this.setTimescale(enabled, { rate: enabled ? (options.rate || 0.8) : 1.0 });
-    }
-
-    setNightcore(enabled, options = {}) {
-        this.presets.nightcore = enabled;
-        return this.setTimescale(enabled, { rate: enabled ? (options.rate || 1.5) : 1.0 });
-    }
-
-    setVaporwave(enabled, options = {}) {
-        this.presets.vaporwave = enabled;
-        return this.setTimescale(enabled, { pitch: enabled ? (options.pitch || 0.5) : 1.0 });
-    }
-
-    set8D(enabled, options = {}) {
-        this.presets._8d = enabled;
-        return this.setRotation(enabled, { rotationHz: enabled ? (options.rotationHz || 0.2) : 0.0 });
-    }
-
-    async clearFilters() {
-        Object.keys(this.filters).forEach(key => {
-            this.filters[key] = key === 'volume' ? 1 : (key === 'equalizer' ? [] : null);
-        });
-        
-        Object.keys(this.presets).forEach(key => {
-            this.presets[key] = null;
-        });
-        
-        this._pendingUpdate = false;
-        if (this._updateTimeout) {
-            clearTimeout(this._updateTimeout);
-            this._updateTimeout = null;
-        }
-        
-        await this.updateFilters();
-        return this;
-    }
-
-    async updateFilters() {
-        if (!this._pendingUpdate && this._updateTimeout) {
-            clearTimeout(this._updateTimeout);
-            this._updateTimeout = null;
-            return this;
-        }
-        
-        this._pendingUpdate = false;
-        this._updateTimeout = null;
-        
-        await this.player.nodes.rest.updatePlayer({
-            guildId: this.player.guildId,
-            data: { filters: { ...this.filters } }
-        });
-
-        return this;
-    }
+  static defaults = {
+    karaoke: { level: 1, monoLevel: 1, filterBand: 220, filterWidth: 100 },
+    timescale: { speed: 1, pitch: 1, rate: 1 },
+    tremolo: { frequency: 2, depth: 0.5 },
+    vibrato: { frequency: 2, depth: 0.5 },
+    rotation: { rotationHz: 0 },
+    distortion: { sinOffset: 0, sinScale: 1, cosOffset: 0, cosScale: 1, tanOffset: 0, tanScale: 1, offset: 0, scale: 1 },
+    channelMix: { leftToLeft: 1, leftToRight: 0, rightToLeft: 0, rightToRight: 1 },
+    lowPass: { smoothing: 20 }
+  }
+
+  constructor(player, options = {}) {
+    this.player = player
+    this._pendingUpdate = false
+
+    this.filters = {
+      volume: options.volume ?? 1,
+      equalizer: options.equalizer ?? [],
+      karaoke: options.karaoke ?? null,
+      timescale: options.timescale ?? null,
+      tremolo: options.tremolo ?? null,
+      vibrato: options.vibrato ?? null,
+      rotation: options.rotation ?? null,
+      distortion: options.distortion ?? null,
+      channelMix: options.channelMix ?? null,
+      lowPass: options.lowPass ?? null
+    }
+
+    this.presets = {
+      bassboost: options.bassboost ?? null,
+      slowmode: options.slowmode ?? null,
+      nightcore: options.nightcore ?? null,
+      vaporwave: options.vaporwave ?? null,
+      _8d: options._8d ?? null
+    }
+  }
+
+  _setFilter(filterName, enabled, options = {}) {
+    const filter = enabled ? { ...Filters.defaults[filterName], ...options } : null
+    if (this.filters[filterName] === filter) return this
+
+    this.filters[filterName] = filter
+    return this._scheduleUpdate()
+  }
+
+  _scheduleUpdate() {
+    if (this._pendingUpdate) return this
+    this._pendingUpdate = true
+
+    queueMicrotask(() => {
+      this._pendingUpdate = false
+      this.updateFilters()
+    })
+
+    return this
+  }
+
+  setEqualizer(bands) {
+    if (this.filters.equalizer === bands) return this
+    this.filters.equalizer = bands || []
+    return this._scheduleUpdate()
+  }
+
+  setKaraoke(enabled, options = {}) {
+    return this._setFilter('karaoke', enabled, options)
+  }
+
+  setTimescale(enabled, options = {}) {
+    return this._setFilter('timescale', enabled, options)
+  }
+
+  setTremolo(enabled, options = {}) {
+    return this._setFilter('tremolo', enabled, options)
+  }
+
+  setVibrato(enabled, options = {}) {
+    return this._setFilter('vibrato', enabled, options)
+  }
+
+  setRotation(enabled, options = {}) {
+    return this._setFilter('rotation', enabled, options)
+  }
+
+  setDistortion(enabled, options = {}) {
+    return this._setFilter('distortion', enabled, options)
+  }
+
+  setChannelMix(enabled, options = {}) {
+    return this._setFilter('channelMix', enabled, options)
+  }
+
+  setLowPass(enabled, options = {}) {
+    return this._setFilter('lowPass', enabled, options)
+  }
+
+  setBassboost(enabled, options = {}) {
+    if (!enabled) {
+      if (this.presets.bassboost === null) return this
+      this.presets.bassboost = null
+      return this.setEqualizer([])
+    }
+
+    const value = options.value ?? 5
+    if (value < 0 || value > 5) throw new Error('Bassboost value must be between 0 and 5')
+    if (this.presets.bassboost === value) return this
+
+    this.presets.bassboost = value
+    const gain = (value - 1) * (1.25 / 9) - 0.25
+    const eq = Array(13).fill().map((_, band) => ({ band, gain }))
+
+    return this.setEqualizer(eq)
+  }
+
+  setSlowmode(enabled, options = {}) {
+    const rate = enabled ? options.rate ?? 0.8 : 1
+    if (this.presets.slowmode === enabled && this.filters.timescale?.rate === rate) return this
+
+    this.presets.slowmode = enabled
+    return this.setTimescale(enabled, { rate })
+  }
+
+  setNightcore(enabled, options = {}) {
+    const rate = enabled ? options.rate ?? 1.5 : 1
+    if (this.presets.nightcore === enabled && this.filters.timescale?.rate === rate) return this
+
+    this.presets.nightcore = enabled
+    return this.setTimescale(enabled, { rate })
+  }
+
+  setVaporwave(enabled, options = {}) {
+    const pitch = enabled ? options.pitch ?? 0.5 : 1
+    if (this.presets.vaporwave === enabled && this.filters.timescale?.pitch === pitch) return this
+
+    this.presets.vaporwave = enabled
+    return this.setTimescale(enabled, { pitch })
+  }
+
+  set8D(enabled, options = {}) {
+    const rotationHz = enabled ? options.rotationHz ?? 0.2 : 0
+    if (this.presets._8d === enabled && this.filters.rotation?.rotationHz === rotationHz) return this
+
+    this.presets._8d = enabled
+    return this.setRotation(enabled, { rotationHz })
+  }
+
+  async clearFilters() {
+    let needsUpdate = false
+
+    // Reset filters
+    Object.keys(this.filters).forEach(key => {
+      const newValue = key === 'volume' ? 1 : key === 'equalizer' ? [] : null
+      if (this.filters[key] !== newValue) {
+        this.filters[key] = newValue
+        needsUpdate = true
+      }
+    })
+
+    // Reset presets
+    Object.keys(this.presets).forEach(key => {
+      if (this.presets[key] !== null) {
+        this.presets[key] = null
+      }
+    })
+
+    if (!needsUpdate) return this
+    return this.updateFilters()
+  }
+
+  async updateFilters() {
+    await this.player.nodes.rest.updatePlayer({
+      guildId: this.player.guildId,
+      data: { filters: this.filters }
+    })
+
+    return this
+  }
 }
 
-module.exports = Filters;
+module.exports = Filters