yukimu 1.2.0 → 2.0.0

package/src/Player.ts

@@ -1,337 +0,0 @@
-import { Queue } from "./Queue";
-import { PlayerState } from "./Constants";
-import { PlayerError } from "./errors/YukimuError";
-import type { Yukimu } from "./Yukimu";
-import type { Node } from "./Node";
-import type { Track, PlayerOptions, VoiceState, FilterOptions } from "./types";
-
-export class Player {
-  public readonly manager: Yukimu;
-  public node: Node;
-  public readonly queue: Queue;
-
-  // IDs
-  public readonly guildId: string;
-  public voiceChannelId: string | null;
-  public textChannelId?: string;
-
-  // State
-  public state: PlayerState = PlayerState.DISCONNECTED;
-  public playing: boolean = false;
-  public paused: boolean = false;
-  public position: number = 0;
-  public ping: number = -1;
-  public lastUpdated: number = Date.now();
-  public volume: number;
-  public loop: "none" | "track" | "queue" = "none";
-
-  // Voice
-  public sessionId: string | null = null;
-  public voiceToken: string | null = null;
-  public voiceEndpoint: string | null = null;
-  public selfDeaf: boolean;
-  public selfMute: boolean;
-
-  // Filters
-  public filters: FilterOptions = {};
-
-  // Data store (like Kazagumo's player.data)
-  public readonly data: Map<string, unknown> = new Map();
-
-  // Autoplay
-  public autoplay: boolean = false;
-
-  constructor(manager: Yukimu, node: Node, options: PlayerOptions) {
-    this.manager = manager;
-    this.node = node;
-    this.queue = new Queue();
-
-    this.guildId = options.guildId;
-    this.voiceChannelId = options.voiceChannelId;
-    this.textChannelId = options.textChannelId;
-    this.volume = options.volume ?? 100;
-    this.selfDeaf = options.selfDeaf ?? true;
-    this.selfMute = options.selfMute ?? false;
-
-    this.sendVoicePayload(options.voiceChannelId, this.selfDeaf, this.selfMute);
-    this.state = PlayerState.CONNECTING;
-  }
-
-  // ─── Getters ──────────────────────────────────────────────────────
-
-  get connected(): boolean {
-    return this.state === PlayerState.CONNECTED;
-  }
-
-  /** Real-time position estimate */
-  get realPosition(): number {
-    if (!this.playing || this.paused) return this.position;
-    return Math.min(this.position + (Date.now() - this.lastUpdated), this.queue.current?.info.length ?? this.position);
-  }
-
-  // ─── Voice ───────────────────────────────────────────────────────
-
-  public sendVoicePayload(channelId: string | null, selfDeaf: boolean, selfMute: boolean): void {
-    this.manager.connector.sendPayload(this.guildId, {
-      op: 4,
-      d: { guild_id: this.guildId, channel_id: channelId, self_deaf: selfDeaf, self_mute: selfMute },
-    });
-  }
-
-  public checkVoiceReady(): void {
-    if (!this.sessionId || !this.voiceToken || !this.voiceEndpoint) return;
-
-    const voiceState: VoiceState = {
-      token: this.voiceToken,
-      endpoint: this.voiceEndpoint,
-      sessionId: this.sessionId,
-    };
-
-    if (this.node.version === 4) {
-      this.node.rest.updatePlayer(this.guildId, { voice: voiceState }).catch(console.error);
-    } else {
-      this.node.send({
-        op: "voiceUpdate",
-        guildId: this.guildId,
-        sessionId: this.sessionId,
-        event: { token: this.voiceToken, guild_id: this.guildId, endpoint: this.voiceEndpoint },
-      });
-    }
-
-    this.state = PlayerState.CONNECTED;
-  }
-
-  // ─── Playback ─────────────────────────────────────────────────────
-
-  public async play(track?: Track, options?: { startTime?: number; endTime?: number; noReplace?: boolean }): Promise<void> {
-    const toPlay = track ?? this.queue.current;
-    if (!toPlay) throw new PlayerError("No track to play");
-
-    this.queue.current = toPlay;
-
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, {
-        track: { encoded: toPlay.encoded },
-        volume: this.volume,
-        ...(options?.startTime !== undefined && { position: options.startTime }),
-        ...(options?.endTime !== undefined && { endTime: options.endTime }),
-      }, options?.noReplace ?? false);
-    } else {
-      this.node.send({
-        op: "play",
-        guildId: this.guildId,
-        track: toPlay.encoded,
-        volume: String(this.volume),
-        ...(options?.startTime !== undefined && { startTime: String(options.startTime) }),
-        ...(options?.endTime !== undefined && { endTime: String(options.endTime) }),
-        ...(options?.noReplace !== undefined && { noReplace: options.noReplace }),
-      });
-    }
-
-    this.playing = true;
-    this.paused = false;
-    this.lastUpdated = Date.now();
-  }
-
-  public async pause(state: boolean = true): Promise<void> {
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { paused: state });
-    } else {
-      this.node.send({ op: "pause", guildId: this.guildId, pause: state });
-    }
-    this.paused = state;
-    this.playing = !state;
-  }
-
-  public async resume(): Promise<void> { return this.pause(false); }
-
-  public async stop(): Promise<void> {
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { track: { encoded: null } });
-    } else {
-      this.node.send({ op: "stop", guildId: this.guildId });
-    }
-    this.playing = false;
-    this.paused = false;
-    this.position = 0;
-    this.queue.current = null;
-  }
-
-  public async skip(): Promise<Track | null> {
-    const next = this.queue.next();
-    if (next) {
-      await this.play(next);
-    } else {
-      await this.stop();
-      this.manager.emit("queueEnd", this);
-    }
-    return next;
-  }
-
-  public async seek(position: number): Promise<void> {
-    if (!this.queue.current?.info.isSeekable) throw new PlayerError("Current track is not seekable");
-    if (position < 0 || position > (this.queue.current.info.length ?? Infinity)) {
-      throw new PlayerError(`Seek position out of range: ${position}`);
-    }
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { position });
-    } else {
-      this.node.send({ op: "seek", guildId: this.guildId, position });
-    }
-    this.position = position;
-    this.lastUpdated = Date.now();
-  }
-
-  public async setVolume(volume: number): Promise<void> {
-    if (volume < 0 || volume > 1000) throw new PlayerError("Volume must be between 0 and 1000");
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { volume });
-    } else {
-      this.node.send({ op: "volume", guildId: this.guildId, volume });
-    }
-    this.volume = volume;
-  }
-
-  // ─── Filters ──────────────────────────────────────────────────────
-
-  public async setFilters(filters: FilterOptions): Promise<void> {
-    this.filters = { ...this.filters, ...filters };
-
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { filters: this.filters });
-    } else {
-      if (filters.equalizer) {
-        this.node.send({ op: "equalizer", guildId: this.guildId, bands: filters.equalizer });
-      }
-      const rest = { ...filters };
-      delete rest.equalizer;
-      if (Object.keys(rest).length > 0) {
-        this.node.send({ op: "filters", guildId: this.guildId, ...rest });
-      }
-    }
-  }
-
-  public async clearFilters(): Promise<void> {
-    this.filters = {};
-    if (this.node.version === 4) {
-      await this.node.rest.updatePlayer(this.guildId, { filters: {} });
-    } else {
-      this.node.send({ op: "filters", guildId: this.guildId });
-    }
-  }
-
-  // ─── Preset Filters ───────────────────────────────────────────────
-
-  public async setBassBoost(level: "off" | "low" | "medium" | "high" | "extreme"): Promise<void> {
-    const presets: Record<string, number[]> = {
-      off:     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      low:     [0.2, 0.15, 0.1, 0.05, 0.0, -0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      medium:  [0.4, 0.3, 0.2, 0.1, 0.05, -0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      high:    [0.6, 0.5, 0.4, 0.25, 0.1, -0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      extreme: [1.0, 0.8, 0.6, 0.4, 0.2, -0.2, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-    };
-    await this.setFilters({ equalizer: presets[level].map((gain, band) => ({ band, gain })) });
-  }
-
-  public async setNightcore(enabled: boolean): Promise<void> {
-    await this.setFilters({ timescale: enabled ? { speed: 1.2, pitch: 1.2, rate: 1.0 } : undefined });
-  }
-
-  public async setVaporwave(enabled: boolean): Promise<void> {
-    await this.setFilters({ timescale: enabled ? { speed: 0.8, pitch: 0.8, rate: 1.0 } : undefined });
-  }
-
-  public async set8D(enabled: boolean): Promise<void> {
-    await this.setFilters({ rotation: enabled ? { rotationHz: 0.2 } : undefined });
-  }
-
-  public async setKaraoke(enabled: boolean): Promise<void> {
-    await this.setFilters({
-      karaoke: enabled ? { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 } : undefined,
-    });
-  }
-
-  public async setTremolo(enabled: boolean, frequency = 2.0, depth = 0.5): Promise<void> {
-    await this.setFilters({ tremolo: enabled ? { frequency, depth } : undefined });
-  }
-
-  public async setVibrato(enabled: boolean, frequency = 2.0, depth = 0.5): Promise<void> {
-    await this.setFilters({ vibrato: enabled ? { frequency, depth } : undefined });
-  }
-
-  public async setLowPass(enabled: boolean, smoothing = 20.0): Promise<void> {
-    await this.setFilters({ lowPass: enabled ? { smoothing } : undefined });
-  }
-
-  // ─── Queue Helpers ────────────────────────────────────────────────
-
-  public async add(tracks: Track | Track[], requester?: unknown): Promise<void> {
-    const arr = Array.isArray(tracks) ? tracks : [tracks];
-
-    // Attach requester to each track
-    if (requester) arr.forEach(t => { (t as any).requester = requester; });
-
-    if (!this.queue.current && arr.length > 0) {
-      const first = arr.shift()!;
-      this.queue.add(arr);
-      await this.play(first);
-    } else {
-      this.queue.add(arr);
-    }
-  }
-
-  public setLoop(mode: "none" | "track" | "queue"): void {
-    this.loop = mode;
-  }
-
-  public setAutoplay(enabled: boolean): void {
-    this.autoplay = enabled;
-  }
-
-  // ─── Node Moving ──────────────────────────────────────────────────
-
-  /** Move player to a different Lavalink node */
-  public async moveToNode(node: Node): Promise<void> {
-    if (this.node === node) return;
-    const oldNode = this.node;
-    this.node = node;
-
-    // Destroy on old node
-    await oldNode.rest.destroyPlayer(this.guildId).catch(() => {});
-
-    // Recreate on new node with current state
-    if (this.queue.current) {
-      await this.play(this.queue.current, { startTime: this.realPosition });
-    }
-
-    // Reapply filters and volume
-    if (Object.keys(this.filters).length > 0) {
-      await this.setFilters(this.filters).catch(() => {});
-    }
-    if (this.volume !== 100) {
-      await this.setVolume(this.volume).catch(() => {});
-    }
-  }
-
-  // ─── Voice Channel Moves ──────────────────────────────────────────
-
-  public async move(channelId: string): Promise<void> {
-    this.voiceChannelId = channelId;
-    this.sendVoicePayload(channelId, this.selfDeaf, this.selfMute);
-  }
-
-  // ─── Destroy ──────────────────────────────────────────────────────
-
-  public async destroy(): Promise<void> {
-    this.state = PlayerState.DISCONNECTING;
-    this.sendVoicePayload(null, false, false);
-
-    await this.node.rest.destroyPlayer(this.guildId).catch(() => {});
-
-    this.playing = false;
-    this.paused = false;
-    this.queue.clear();
-    this.data.clear();
-    this.state = PlayerState.DISCONNECTED;
-  }
-}

package/src/Plugin.ts

@@ -1,23 +0,0 @@
-import type { Yukimu } from "./Yukimu";
-
-/**
- * Base Plugin class — extend this to create Yukimu plugins.
- * Similar to Kazagumo's plugin system.
- *
- * Example:
- * class MyPlugin extends Plugin {
- *   public name = "MyPlugin";
- *   public load(manager: Yukimu) {
- *     manager.on("trackStart", (player, track) => { ... });
- *   }
- * }
- */
-export abstract class Plugin {
-  public abstract name: string;
-
-  /** Called when plugin is loaded into Yukimu */
-  public abstract load(manager: Yukimu): void;
-
-  /** Called when plugin is unloaded */
-  public unload?(manager: Yukimu): void;
-}

package/src/Queue.ts

@@ -1,91 +0,0 @@
-import type { Track } from "./types";
-
-export class Queue {
-  public current: Track | null = null;
-  public previous: Track[] = [];
-  private tracks: Track[] = [];
-
-  // ─── Add / Remove ─────────────────────────────────────────────────
-
-  public add(tracks: Track | Track[], position?: number): void {
-    const arr = Array.isArray(tracks) ? tracks : [tracks];
-    if (position !== undefined) {
-      this.tracks.splice(position, 0, ...arr);
-    } else {
-      this.tracks.push(...arr);
-    }
-  }
-
-  public next(): Track | null {
-    if (this.current) {
-      this.previous.unshift(this.current);
-      if (this.previous.length > 10) this.previous.pop(); // keep last 10
-    }
-    this.current = this.tracks.shift() ?? null;
-    return this.current;
-  }
-
-  public remove(index: number): Track | null {
-    if (index < 0 || index >= this.tracks.length) return null;
-    const [removed] = this.tracks.splice(index, 1);
-    return removed;
-  }
-
-  public removeRange(start: number, end: number): Track[] {
-    return this.tracks.splice(start, end - start);
-  }
-
-  public clear(): void {
-    this.tracks = [];
-    this.current = null;
-    this.previous = [];
-  }
-
-  // ─── Reorder ──────────────────────────────────────────────────────
-
-  public shuffle(): void {
-    for (let i = this.tracks.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
-    }
-  }
-
-  public move(from: number, to: number): void {
-    if (from < 0 || to < 0 || from >= this.tracks.length || to >= this.tracks.length) return;
-    const [track] = this.tracks.splice(from, 1);
-    this.tracks.splice(to, 0, track);
-  }
-
-  /** Skip to a specific position in queue */
-  public skipto(index: number): Track | null {
-    if (index < 0 || index >= this.tracks.length) return null;
-    this.tracks.splice(0, index);
-    return this.next();
-  }
-
-  // ─── Peek / Find ──────────────────────────────────────────────────
-
-  public peek(count: number = 10): Track[] {
-    return this.tracks.slice(0, count);
-  }
-
-  public find(predicate: (track: Track) => boolean): Track | undefined {
-    return this.tracks.find(predicate);
-  }
-
-  public filter(predicate: (track: Track) => boolean): Track[] {
-    return this.tracks.filter(predicate);
-  }
-
-  // ─── Getters ──────────────────────────────────────────────────────
-
-  get size(): number { return this.tracks.length; }
-
-  get isEmpty(): boolean { return this.tracks.length === 0; }
-
-  get totalDuration(): number {
-    return this.tracks.reduce((acc, t) => acc + (t.info?.length ?? 0), 0);
-  }
-
-  get list(): ReadonlyArray<Track> { return this.tracks; }
-}

package/src/Resolver.ts

@@ -1,79 +0,0 @@
-import { SOURCE_PREFIXES, URL_PATTERNS } from "./Constants";
-import type { Yukimu } from "./Yukimu";
-import type { SearchResult, SearchSource, Track } from "./types";
-
-export class Resolver {
-  private manager: Yukimu;
-  private spotifyToken: string | null = null;
-  private spotifyExpiry: number = 0;
-
-  constructor(manager: Yukimu) {
-    this.manager = manager;
-  }
-
-  public async resolve(query: string, source: SearchSource, requester?: unknown): Promise<SearchResult> {
-    const node = this.manager.getBestNode();
-    const isUrl = /^https?:\/\//.test(query);
-    const identifier = isUrl ? query : `${SOURCE_PREFIXES[source] ?? "ytsearch"}:${query}`;
-
-    const result = await node.loadTracks(identifier);
-
-    // Attach requester
-    if (requester) result.tracks.forEach(t => { (t as Track & { requester: unknown }).requester = requester; });
-
-    // Spotify fallback — if LavaSrc not installed
-    if ((result.loadType === "error" || result.loadType === "empty") && isUrl) {
-      const spotifyMatch = query.match(/spotify\.com\/track\/([a-zA-Z0-9]+)/);
-      if (spotifyMatch) {
-        const meta = await this.resolveSpotifyMeta(spotifyMatch[1]);
-        if (meta) return this.resolve(`${meta.title} ${meta.artist}`, "youtube", requester);
-      }
-    }
-
-    // Cache all returned tracks
-    for (const track of result.tracks) {
-      if (track.encoded) this.manager.trackCache.set(track.encoded, track);
-    }
-
-    return result;
-  }
-
-  public detectSource(url: string): SearchSource | null {
-    for (const [source, patterns] of Object.entries(URL_PATTERNS)) {
-      if (patterns.some(p => p.test(url))) return source as SearchSource;
-    }
-    return null;
-  }
-
-  private async getSpotifyToken(): Promise<string | null> {
-    const opts = this.manager.options.spotify;
-    if (!opts) return null;
-    if (this.spotifyToken && Date.now() < this.spotifyExpiry) return this.spotifyToken;
-    try {
-      const res = await fetch("https://accounts.spotify.com/api/token", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Authorization: `Basic ${Buffer.from(`${opts.clientId}:${opts.clientSecret}`).toString("base64")}`,
-        },
-        body: "grant_type=client_credentials",
-      });
-      const data = await res.json() as { access_token: string; expires_in: number };
-      this.spotifyToken = data.access_token;
-      this.spotifyExpiry = Date.now() + data.expires_in * 1000 - 5000;
-      return this.spotifyToken;
-    } catch { return null; }
-  }
-
-  private async resolveSpotifyMeta(trackId: string): Promise<{ title: string; artist: string } | null> {
-    const token = await this.getSpotifyToken();
-    if (!token) return null;
-    try {
-      const res = await fetch(`https://api.spotify.com/v1/tracks/${trackId}`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      const data = await res.json() as { name: string; artists: { name: string }[] };
-      return { title: data.name, artist: data.artists[0]?.name ?? "Unknown" };
-    } catch { return null; }
-  }
-}

package/src/Rest.ts

@@ -1,121 +0,0 @@
-import { RestError } from "./errors/YukimuError";
-import type { Node } from "./Node";
-import type { SearchResult, Track, NodeStats, NodeInfo } from "./types";
-
-const TIMEOUT_MS = 15000;
-
-export class Rest {
-  private node: Node;
-
-  constructor(node: Node) {
-    this.node = node;
-  }
-
-  get baseUrl(): string {
-    const protocol = this.node.options.secure ? "https" : "http";
-    return `${protocol}://${this.node.options.host}:${this.node.options.port}`;
-  }
-
-  get prefix(): string {
-    return this.node.version === 4 ? "/v4" : "";
-  }
-
-  get headers(): Record<string, string> {
-    return {
-      Authorization: this.node.options.password,
-      "User-Id": this.node.manager.options.clientId,
-      "Client-Name": "Yukimu/1.2.0",
-      "Content-Type": "application/json",
-      ...(this.node.version === 3 ? { "Num-Shards": "1" } : {}),
-    };
-  }
-
-  public async request<T = unknown>(method: string, path: string, body?: unknown): Promise<T> {
-    const url = `${this.baseUrl}${this.prefix}${path}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
-
-    try {
-      const res = await (globalThis as any).fetch(url, {
-        method,
-        headers: this.headers,
-        body: body ? JSON.stringify(body) : undefined,
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeout);
-
-      if (!res.ok) {
-        const text = await res.text().catch(() => "Unknown error");
-        throw new RestError(`REST ${res.status} on ${method} ${path}: ${text}`, res.status, path);
-      }
-
-      if (res.status === 204) return undefined as T;
-      return res.json() as Promise<T>;
-    } catch (err: any) {
-      clearTimeout(timeout);
-      if (err.name === "AbortError") throw new RestError(`REST timeout on ${method} ${path}`, 408, path);
-      throw err;
-    }
-  }
-
-  public async loadTracks(identifier: string): Promise<SearchResult> {
-    const raw = await this.request<Record<string, unknown>>("GET", `/loadtracks?identifier=${encodeURIComponent(identifier)}`);
-    return this.node.version === 3 ? this.normalizeV3(raw) : raw as unknown as SearchResult;
-  }
-
-  public async decodeTrack(encoded: string): Promise<Track> {
-    return this.request("GET", `/decodetrack?encodedTrack=${encodeURIComponent(encoded)}`);
-  }
-
-  public async decodeTracks(encoded: string[]): Promise<Track[]> {
-    return this.request("POST", `/decodetracks`, encoded);
-  }
-
-  public async getInfo(): Promise<NodeInfo> {
-    return this.request("GET", "/info");
-  }
-
-  public async getStats(): Promise<NodeStats> {
-    return this.request("GET", "/stats");
-  }
-
-  public async getVersion(): Promise<string> {
-    const res = await (globalThis as any).fetch(`${this.baseUrl}/version`, { headers: this.headers });
-    return res.text();
-  }
-
-  public async updatePlayer(guildId: string, body: unknown, noReplace = false): Promise<unknown> {
-    const path = this.node.version === 4
-      ? `/sessions/${this.node.sessionId}/players/${guildId}?noReplace=${noReplace}`
-      : `/players/${guildId}`;
-    return this.request("PATCH", path, body);
-  }
-
-  public async destroyPlayer(guildId: string): Promise<void> {
-    const path = this.node.version === 4
-      ? `/sessions/${this.node.sessionId}/players/${guildId}`
-      : `/players/${guildId}`;
-    await this.request("DELETE", path);
-  }
-
-  public async updateSession(body: { resuming?: boolean; timeout?: number }): Promise<unknown> {
-    if (this.node.version !== 4) return;
-    return this.request("PATCH", `/sessions/${this.node.sessionId}`, body);
-  }
-
-  private normalizeV3(raw: Record<string, unknown>): SearchResult {
-    const loadType = ((raw.loadType as string) ?? "").toLowerCase();
-    const norm = (tracks: unknown[]): Track[] =>
-      (tracks ?? []).map((t: any) => ({ encoded: t.track ?? t.encoded, info: t.info, pluginInfo: t.pluginInfo ?? {} }));
-
-    switch (loadType) {
-      case "track_loaded": return { loadType: "track", tracks: norm(raw.tracks as unknown[]) };
-      case "playlist_loaded": return { loadType: "playlist", tracks: norm(raw.tracks as unknown[]), playlistInfo: raw.playlistInfo as any };
-      case "search_result": return { loadType: "search", tracks: norm(raw.tracks as unknown[]) };
-      case "no_matches": return { loadType: "empty", tracks: [] };
-      case "load_failed": return { loadType: "error", tracks: [], exception: raw.exception as any };
-      default: return { loadType: "empty", tracks: [] };
-    }
-  }
-}