ryanlink 1.0.2 → 2.0.0

package/src/voice/RegionSelector.ts

@@ -1,184 +0,0 @@
-import { OnPingUpdateSymbol } from "../config/symbols";
-import type { PlayerState } from "../types";
-import type { Player } from "../core/RyanlinkPlayer";
-
-/**
- * Voice node ping statistics
- */
-interface VoiceNodePingStats {
-    /**
-     * History of ping measurements (up to 5 samples)
-     */
-    history: number[];
-
-    /**
-     * Timestamp of last ping measurement
-     */
-    lastPingTime: number;
-}
-
-/**
- * Represents a voice region with node ping tracking
- * Used for latency-based node selection
- */
-export class VoiceRegion {
-    #pings = new Map<string, VoiceNodePingStats>();
-
-    readonly id: string;
-    readonly player: Player;
-
-    constructor(player: Player, regionId: string) {
-        if (player.voices.regions.has(regionId)) {
-            throw new Error("An identical voice region already exists");
-        }
-
-        this.id = regionId;
-        this.player = player;
-
-        // Make properties immutable
-        const immutable: PropertyDescriptor = {
-            writable: false,
-            configurable: false,
-        };
-
-        Object.defineProperties(this, {
-            id: immutable,
-            player: { ...immutable, enumerable: false },
-        } as PropertyDescriptorMap);
-    }
-
-    /**
-     * Check if all ready nodes have ping data for this region
-     * @returns `true` if all nodes are synced, `false` otherwise
-     */
-    inSync(): boolean {
-        return !Array.from(this.player.nodes.values()).some((n) => n.ready && !this.#pings.has(n.name));
-    }
-
-    /**
-     * Remove ping data for a node
-     * @param name Node name
-     * @returns `true` if data was removed, `false` if it didn't exist
-     */
-    forgetNode(name: string): boolean {
-        return this.#pings.delete(name);
-    }
-
-    /**
-     * Get the average ping for a node in this region
-     * @param name Node name
-     * @returns Average ping in milliseconds, or `null` if no data
-     */
-    getAveragePing(name: string): number | null {
-        const pings = this.#pings.get(name)?.history;
-        if (!pings?.length) {
-            return null;
-        }
-
-        return Math.round(pings.reduce((total, current) => total + current, 0) / pings.length);
-    }
-
-    /**
-     * Get all nodes with their average pings
-     * @returns Array of [nodeName, averagePing] tuples
-     */
-    getAllPings(): Array<[string, number | null]> {
-        return Array.from(this.player.nodes.values()).map((node) => [node.name, this.getAveragePing(node.name)]);
-    }
-
-    /**
-     * Get the most relevant node for this region
-     * Selects based on lowest average ping
-     * @returns The node with lowest ping, or first relevant node if no ping data
-     */
-    getRelevantNode() {
-        return this.player.nodes.relevant().sort((a, b) => {
-            const pingA = this.getAveragePing(a.name) ?? Number.MAX_SAFE_INTEGER;
-            const pingB = this.getAveragePing(b.name) ?? Number.MAX_SAFE_INTEGER;
-            return pingA - pingB;
-        })[0];
-    }
-
-    /**
-     * Internal method to update ping statistics
-     * Called by the voice manager when player state updates
-     * @param name Node name
-     * @param state Player state with ping information
-     * @internal
-     */
-    [OnPingUpdateSymbol](name: string, state: PlayerState): void {
-        // Only process if connected and has valid ping data
-        if (!state.connected) {
-            return;
-        }
-        if (state.ping <= 0 || state.time <= 0) {
-            return;
-        }
-
-        const pings = this.#pings.get(name);
-
-        // Initialize ping tracking for this node
-        if (!pings) {
-            this.#pings.set(name, {
-                history: [state.ping],
-                lastPingTime: state.time,
-            });
-            return;
-        }
-
-        // Only update if enough time has passed (12 seconds)
-        if (state.time - pings.lastPingTime < 12_000) {
-            return;
-        }
-
-        pings.lastPingTime = state.time;
-        pings.history.push(state.ping);
-
-        // Keep only last 5 samples
-        if (pings.history.length > 5) {
-            pings.history.shift();
-        }
-    }
-
-    /**
-     * Clear all ping data for this region
-     */
-    clear(): void {
-        this.#pings.clear();
-    }
-
-    /**
-     * Get the number of nodes with ping data
-     */
-    get nodeCount(): number {
-        return this.#pings.size;
-    }
-
-    /**
-     * String representation of the voice region
-     */
-    toString(): string {
-        return `VoiceRegion<${this.id}>`;
-    }
-
-    /**
-     * JSON representation of the voice region
-     */
-    toJSON(): {
-        id: string;
-        inSync: boolean;
-        nodeCount: number;
-        pings: Array<{ node: string; averagePing: number | null; samples: number }>;
-    } {
-        return {
-            id: this.id,
-            inSync: this.inSync(),
-            nodeCount: this.nodeCount,
-            pings: Array.from(this.#pings.entries()).map(([node, stats]) => ({
-                node,
-                averagePing: this.getAveragePing(node),
-                samples: stats.history.length,
-            })),
-        };
-    }
-}

package/src/voice/VoiceConnection.ts

@@ -1,458 +0,0 @@
-import { setTimeout } from "node:timers/promises";
-import { SnowflakeRegex, VoiceRegionIdRegex } from "../config";
-import { LookupSymbol, OnVoiceCloseSymbol, UpdateSymbol } from "../config/symbols";
-import { isString, noop } from "../utils";
-import { VoiceRegion } from "./RegionSelector";
-import { VoiceState } from "./VoiceSession";
-import {
-    VoiceCloseCodes,
-    type BotReadyPayload,
-    type BotVoiceState,
-    type ConnectOptions,
-    type CreateQueueOptions,
-    type DiscordDispatchPayload,
-    type VoiceServerUpdatePayload,
-    type VoiceStateUpdatePayload,
-} from "../types";
-import type { Player } from "../core/RyanlinkPlayer";
-
-/**
- * Join request with promise resolvers
- */
-interface JoinRequest extends Pick<CreateQueueOptions, "context" | "node" | "voiceId"> {
-    promise: Promise<VoiceState>;
-    resolve: (value: VoiceState | PromiseLike<VoiceState>) => void;
-    reject: (reason?: unknown) => void;
-    config?: Pick<CreateQueueOptions, "filters" | "volume">;
-}
-
-/**
- * Manages voice connections for all guilds
- * Handles Discord voice events and Lavalink voice state
- */
-export class VoiceManager implements Partial<Map<string, VoiceState>> {
-    #cache = new Map<string, BotVoiceState>();
-    #voices = new Map<string, VoiceState>();
-
-    #joins = new Map<string, JoinRequest>();
-    #destroys = new Map<string, Promise<void>>();
-
-    readonly regions = new Map<string, VoiceRegion>();
-    readonly player: Player;
-
-    constructor(player: Player) {
-        if (player.voices === undefined) {
-            this.player = player;
-        } else {
-            throw new Error("Manager already exists for this Player");
-        }
-
-        const immutable: PropertyDescriptor = {
-            writable: false,
-            configurable: false,
-        };
-
-        Object.defineProperties(this, {
-            regions: immutable,
-            player: { ...immutable, enumerable: false },
-        } as PropertyDescriptorMap);
-    }
-
-    /**
-     * Number of voice connections
-     */
-    get size(): number {
-        return this.#voices.size;
-    }
-
-    /**
-     * Get voice state for a guild
-     */
-    get(guildId: string): VoiceState | undefined {
-        return this.#voices.get(guildId);
-    }
-
-    /**
-     * Check if voice state exists
-     */
-    has(guildId: string): boolean {
-        return this.#voices.has(guildId);
-    }
-
-    /**
-     * Get all connected guild IDs
-     */
-    keys() {
-        return this.#voices.keys();
-    }
-
-    /**
-     * Get all voice connections
-     */
-    values() {
-        return this.#voices.values();
-    }
-
-    /**
-     * Get all voice connections as entries
-     */
-    entries() {
-        return this.#voices.entries();
-    }
-
-    /**
-     * Destroy a voice connection
-     * @param guildId Guild ID
-     * @param reason Reason for destruction
-     */
-    async destroy(guildId: string, reason = "destroyed"): Promise<void> {
-        if (this.player.queues.has(guildId)) {
-            return this.player.queues.destroy(guildId, reason);
-        }
-        if (this.#destroys.has(guildId)) {
-            return this.#destroys.get(guildId) ?? Promise.resolve();
-        }
-
-        const voice = this.#voices.get(guildId);
-        if (!voice) {
-            return;
-        }
-
-        let resolve!: () => void;
-        let reject!: (reason?: unknown) => void;
-        const promise = new Promise<void>((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        const resolver = { promise, resolve, reject };
-        this.#destroys.set(guildId, resolver.promise);
-
-        if (this[LookupSymbol](guildId)?.connected) {
-            await voice.disconnect().catch(noop);
-        }
-
-        this.#cache.delete(guildId);
-        this.#voices.delete(guildId);
-
-        this.player.emit("voiceDestroy", voice, reason);
-
-        resolver.resolve();
-        this.#destroys.delete(guildId);
-    }
-
-    /**
-     * Connect to a voice channel
-     * @param guildId Guild ID
-     * @param voiceId Voice channel ID
-     * @param options Connection options
-     */
-    async connect(guildId: string, voiceId: string, options?: ConnectOptions): Promise<VoiceState> {
-        if (!isString(guildId, SnowflakeRegex)) {
-            throw new Error("Guild Id is not a valid Discord Id");
-        }
-        if (!isString(voiceId, SnowflakeRegex)) {
-            throw new Error("Voice Id is not a valid Discord Id");
-        }
-
-        const currentRequest = this.#joins.get(guildId);
-        if (currentRequest) {
-            if (currentRequest.voiceId === voiceId) {
-                return currentRequest.promise;
-            }
-            currentRequest.reject(new Error("Connection request was replaced"));
-        }
-
-        const state = this.#cache.get(guildId);
-        if (state?.connected && state.channel_id === voiceId) {
-            const voice = this.player.queues.get(guildId)?.voice;
-            if (voice && voice.connected) {
-                return voice;
-            }
-        }
-
-        this.#joins.delete(guildId);
-
-        let resolve!: (value: VoiceState | PromiseLike<VoiceState>) => void;
-        let reject!: (reason?: unknown) => void;
-        const promise = new Promise<VoiceState>((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        const request: JoinRequest = {
-            promise,
-            resolve,
-            reject,
-            voiceId,
-            node: options?.node,
-            context: options?.context,
-            config: options ? { filters: options.filters, volume: options.volume } : undefined,
-        };
-
-        this.#joins.set(guildId, request);
-
-        // Send voice state update to Discord
-        await this.player.options.forwardVoiceUpdate(guildId, {
-            op: 4,
-            d: {
-                guild_id: guildId,
-                channel_id: voiceId,
-                self_deaf: false,
-                self_mute: false,
-            },
-        });
-
-        // Wait for voice connection with timeout
-        const timeout = setTimeout(15_000, undefined, { ref: false });
-        const result = await Promise.race([request.promise, timeout]);
-
-        if (result === undefined) {
-            this.#joins.delete(guildId);
-            throw new Error("Voice connection timed out");
-        }
-
-        return result;
-    }
-
-    /**
-     * Disconnect from voice channel
-     * @param guildId Guild ID
-     */
-    async disconnect(guildId: string): Promise<void> {
-        const state = this.#cache.get(guildId);
-        if (!state) {
-            return;
-        }
-
-        await this.player.options.forwardVoiceUpdate(guildId, {
-            op: 4,
-            d: {
-                guild_id: guildId,
-                channel_id: null,
-                self_deaf: false,
-                self_mute: false,
-            },
-        });
-
-        state.channel_id = "";
-        state.connected = false;
-    }
-
-    /**
-     * Handle Discord dispatch events
-     * @param payload Discord gateway payload
-     */
-    handleDispatch(payload: DiscordDispatchPayload): void {
-        if (payload.t === "READY") {
-            this.#handleReady(payload);
-        } else if (payload.t === "VOICE_STATE_UPDATE") {
-            this.#handleVoiceStateUpdate(payload);
-        } else if (payload.t === "VOICE_SERVER_UPDATE") {
-            this.#handleVoiceServerUpdate(payload);
-        }
-    }
-
-    /**
-     * Internal lookup for voice state
-     * @internal
-     */
-    [LookupSymbol](guildId: string): BotVoiceState | undefined {
-        return this.#cache.get(guildId);
-    }
-
-    /**
-     * Internal update for voice state
-     * @internal
-     */
-    [UpdateSymbol](guildId: string, partial: Partial<BotVoiceState>): void {
-        const state = this.#cache.get(guildId);
-        if (state) {
-            Object.assign(state, partial);
-        }
-    }
-
-    /**
-     * Internal voice close handler
-     * @internal
-     */
-    [OnVoiceCloseSymbol](guildId: string, code: number, reason: string, byRemote: boolean): void {
-        const voice = this.#voices.get(guildId);
-        if (!voice) {
-            return;
-        }
-
-        this.player.emit("voiceClose", voice, code, reason, byRemote);
-
-        // Check if we should destroy the connection
-        const shouldDestroy =
-            (code as VoiceCloseCodes) === VoiceCloseCodes.Disconnected ||
-            (code as VoiceCloseCodes) === VoiceCloseCodes.DisconnectedRateLimited ||
-            (code as VoiceCloseCodes) === VoiceCloseCodes.DisconnectedCallTerminated;
-
-        if (shouldDestroy) {
-            this.destroy(guildId, `Voice closed: ${reason} (${code})`).catch(noop);
-        }
-    }
-
-    /**
-     * Handle READY event
-     */
-    #handleReady(_payload: BotReadyPayload): void {
-        // Clear all voice states on ready
-        this.#cache.clear();
-        this.#voices.clear();
-        this.#joins.clear();
-    }
-
-    /**
-     * Handle VOICE_STATE_UPDATE event
-     */
-    #handleVoiceStateUpdate(payload: VoiceStateUpdatePayload): void {
-        const { d: data } = payload;
-        const guildId = data.guild_id;
-
-        if (!guildId || data.user_id !== this.player.clientId) {
-            return;
-        }
-
-        let state = this.#cache.get(guildId);
-
-        // User left voice channel
-        if (data.channel_id === null) {
-            if (state) {
-                state.channel_id = "";
-                state.connected = false;
-            }
-            return;
-        }
-
-        // Create or update state
-        if (!state) {
-            state = {
-                channel_id: data.channel_id,
-                session_id: data.session_id,
-                deaf: data.deaf,
-                mute: data.mute,
-                self_deaf: data.self_deaf,
-                self_mute: data.self_mute,
-                suppress: data.suppress,
-                token: "",
-                endpoint: "",
-                connected: false,
-                node_session_id: "",
-                reconnecting: false,
-                region_id: "",
-            };
-            this.#cache.set(guildId, state);
-        } else {
-            state.channel_id = data.channel_id;
-            state.session_id = data.session_id;
-            state.deaf = data.deaf;
-            state.mute = data.mute;
-            state.self_deaf = data.self_deaf;
-            state.self_mute = data.self_mute;
-            state.suppress = data.suppress;
-        }
-
-        void this.#tryConnect(guildId);
-    }
-
-    /**
-     * Handle VOICE_SERVER_UPDATE event
-     */
-    #handleVoiceServerUpdate(payload: VoiceServerUpdatePayload): void {
-        const { d: data } = payload;
-        const guildId = data.guild_id;
-
-        let state = this.#cache.get(guildId);
-
-        if (!state) {
-            state = {
-                channel_id: "",
-                session_id: "",
-                deaf: false,
-                mute: false,
-                self_deaf: false,
-                self_mute: false,
-                suppress: false,
-                token: data.token,
-                endpoint: data.endpoint ?? "",
-                connected: false,
-                node_session_id: "",
-                reconnecting: false,
-                region_id: "",
-            };
-            this.#cache.set(guildId, state);
-        } else {
-            state.token = data.token;
-            state.endpoint = data.endpoint ?? "";
-        }
-
-        // Extract region from endpoint
-        if (state.endpoint) {
-            const match = state.endpoint.match(VoiceRegionIdRegex);
-            if (match?.[1]) {
-                state.region_id = match[1];
-
-                // Create or get voice region
-                if (!this.regions.has(state.region_id)) {
-                    this.regions.set(state.region_id, new VoiceRegion(this.player, state.region_id));
-                }
-            }
-        }
-
-        void this.#tryConnect(guildId);
-    }
-
-    /**
-     * Try to establish voice connection
-     */
-    async #tryConnect(guildId: string): Promise<void> {
-        const state = this.#cache.get(guildId);
-        const request = this.#joins.get(guildId);
-
-        if (!state || !request) {
-            return;
-        }
-
-        if (!state.channel_id || !state.session_id || !state.token || !state.endpoint) {
-            return;
-        }
-
-        this.#joins.delete(guildId);
-
-        try {
-            const nodeName =
-                request.node ??
-                (state.region_id && this.regions.get(state.region_id)?.getRelevantNode()?.name) ??
-                this.player.nodes.relevant()[0]?.name;
-
-            if (!nodeName) {
-                throw new Error("No nodes available");
-            }
-
-            let queue = this.player.queues.get(guildId);
-            if (!queue) {
-                queue = await this.player.queues.create({
-                    guildId,
-                    voiceId: state.channel_id,
-                    node: nodeName,
-                    context: request.context,
-                    ...request.config,
-                });
-            }
-
-            const voice = new VoiceState(this.player, nodeName, guildId);
-            this.#voices.set(guildId, voice);
-
-            state.connected = true;
-            state.node_session_id = voice.node.sessionId ?? "";
-
-            await queue.sync("remote").catch(noop);
-
-            this.player.emit("voiceConnect", voice);
-            request.resolve(voice);
-        } catch (error) {
-            request.reject(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-}