yukimu 1.0.0 → 1.2.0

package/src/Player.ts

@@ -1,11 +1,13 @@
 import { Queue } from "./Queue";
-import { Track, PlayerOptions, VoiceState } from "./types";
+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 readonly node: Node;
+  public node: Node;
   public readonly queue: Queue;
 
   // IDs
@@ -14,23 +16,30 @@ export class Player {
   public textChannelId?: string;
 
   // State
+  public state: PlayerState = PlayerState.DISCONNECTED;
   public playing: boolean = false;
   public paused: boolean = false;
-  public connected: 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 connection
+  // 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: Record<string, unknown> = {};
+  public filters: FilterOptions = {};
 
-  // Loop mode
-  public loop: "none" | "track" | "queue" = "none";
+  // 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;
@@ -41,26 +50,34 @@ export class Player {
     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;
+  }
 
-    // Send voice channel join payload to Discord
-    this.sendVoicePayload(options.voiceChannelId, options.selfDeaf ?? true, options.selfMute ?? false);
+  // ─── 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 ───────────────────────────────────────────────────────
 
-  private sendVoicePayload(channelId: string | null, selfDeaf: boolean, selfMute: boolean): void {
-    this.manager.sendPayload(this.guildId, {
+  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,
-      },
+      d: { guild_id: this.guildId, channel_id: channelId, self_deaf: selfDeaf, self_mute: selfMute },
     });
   }
 
-  /** Called when both sessionId and voiceToken/endpoint are available */
   public checkVoiceReady(): void {
     if (!this.sessionId || !this.voiceToken || !this.voiceEndpoint) return;
 
@@ -70,56 +87,76 @@ export class Player {
       sessionId: this.sessionId,
     };
 
-    this.node
-      .request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
-        voice: voiceState,
-      })
-      .catch(console.error);
+    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 ─────────────────────────────────────────────────────
 
-  /** Play a track */
-  public async play(track: Track, options?: { startTime?: number; endTime?: number }): Promise<void> {
-    this.queue.current = track;
+  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");
 
-    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}?noReplace=false`, {
-      track: { encoded: track.encoded },
-      volume: this.volume,
-      ...(options?.startTime && { position: options.startTime }),
-      ...(options?.endTime && { endTime: options.endTime }),
-    });
+    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();
   }
 
-  /** Pause or resume playback */
   public async pause(state: boolean = true): Promise<void> {
-    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
-      paused: state,
-    });
+    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;
   }
 
-  /** Resume playback */
-  public async resume(): Promise<void> {
-    return this.pause(false);
-  }
+  public async resume(): Promise<void> { return this.pause(false); }
 
-  /** Stop playback */
   public async stop(): Promise<void> {
-    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
-      track: { encoded: null },
-    });
+    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;
   }
 
-  /** Skip to next track */
   public async skip(): Promise<Track | null> {
     const next = this.queue.next();
     if (next) {
@@ -131,115 +168,170 @@ export class Player {
     return next;
   }
 
-  /** Seek to position in milliseconds */
   public async seek(position: number): Promise<void> {
-    if (!this.queue.current?.info.isSeekable) throw new Error("Current track is not seekable");
-    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
-      position,
-    });
+    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();
   }
 
-  /** Set volume (0–1000, Lavalink default 100) */
   public async setVolume(volume: number): Promise<void> {
-    if (volume < 0 || volume > 1000) throw new Error("Volume must be between 0 and 1000");
-    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
-      volume,
-    });
+    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 ──────────────────────────────────────────────────────
 
-  /** Apply audio filters (bass boost, nightcore, 8D, etc.) */
-  public async setFilters(filters: Record<string, unknown>): Promise<void> {
-    this.filters = filters;
-    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
-      filters,
-    });
-  }
+  public async setFilters(filters: FilterOptions): Promise<void> {
+    this.filters = { ...this.filters, ...filters };
 
-  /** Enable bass boost */
-  public async setBassBoost(level: "low" | "medium" | "high" | "off"): Promise<void> {
-    const bands: { band: number; gain: number }[] = [];
-    const gains = {
-      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, 0, 0, 0, 0, 0, 0, 0, 0],
-      medium: [0.4, 0.3, 0.2, 0.1, 0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      high: [0.6, 0.5, 0.4, 0.25, 0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-    };
+    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 });
+      }
+    }
+  }
 
-    for (let i = 0; i < 15; i++) {
-      bands.push({ band: i, gain: gains[level][i] });
+  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 ───────────────────────────────────────────────
 
-    await this.setFilters({ ...this.filters, equalizer: bands });
+  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 })) });
   }
 
-  /** Enable nightcore effect */
   public async setNightcore(enabled: boolean): Promise<void> {
-    await this.setFilters({
-      ...this.filters,
-      timescale: enabled ? { speed: 1.2, pitch: 1.2, rate: 1.0 } : {},
-    });
+    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 });
   }
 
-  /** Enable 8D audio */
   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({
-      ...this.filters,
-      rotation: enabled ? { rotationHz: 0.2 } : {},
+      karaoke: enabled ? { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 } : undefined,
     });
   }
 
-  /** Clear all filters */
-  public async clearFilters(): Promise<void> {
-    this.filters = {};
-    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
-      filters: {},
-    });
+  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 ────────────────────────────────────────────────
 
-  /** Add track(s) to queue and optionally start playing */
-  public async add(tracks: Track | Track[], playNow: boolean = false): Promise<void> {
+  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.current = first;
       this.queue.add(arr);
       await this.play(first);
     } else {
       this.queue.add(arr);
-      if (playNow && arr.length > 0) {
-        await this.play(arr[0]);
-      }
     }
   }
 
-  /** Set loop mode */
   public setLoop(mode: "none" | "track" | "queue"): void {
     this.loop = mode;
   }
 
-  // ─── Disconnect ───────────────────────────────────────────────────
+  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 ──────────────────────────────────────────────────────
 
-  /** Disconnect from voice and clean up */
   public async destroy(): Promise<void> {
+    this.state = PlayerState.DISCONNECTING;
     this.sendVoicePayload(null, false, false);
-    await this.node
-      .request("DELETE", `/sessions/${this.node.sessionId}/players/${this.guildId}`)
-      .catch(() => {});
+
+    await this.node.rest.destroyPlayer(this.guildId).catch(() => {});
+
     this.playing = false;
-    this.connected = false;
+    this.paused = false;
     this.queue.clear();
+    this.data.clear();
+    this.state = PlayerState.DISCONNECTED;
   }
-
-  /** Move to a different voice channel */
-  public async move(channelId: string, selfDeaf: boolean = true): Promise<void> {
-    this.voiceChannelId = channelId;
-    this.sendVoicePayload(channelId, selfDeaf, false);
-  }
-}
+}

package/src/Plugin.ts

@@ -0,0 +1,23 @@
+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,47 +1,48 @@
-import { Track } from "./types";
+import type { Track } from "./types";
 
 export class Queue {
   public current: Track | null = null;
-  public previous: Track | null = null;
+  public previous: Track[] = [];
   private tracks: Track[] = [];
 
-  // ─── Basic Operations ─────────────────────────────────────────────
+  // ─── Add / Remove ─────────────────────────────────────────────────
 
-  /** Add tracks to the end of the queue */
-  public add(tracks: Track | Track[]): void {
+  public add(tracks: Track | Track[], position?: number): void {
     const arr = Array.isArray(tracks) ? tracks : [tracks];
-    this.tracks.push(...arr);
+    if (position !== undefined) {
+      this.tracks.splice(position, 0, ...arr);
+    } else {
+      this.tracks.push(...arr);
+    }
   }
 
-  /** Remove and return the next track */
   public next(): Track | null {
-    if (this.current) this.previous = this.current;
+    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;
   }
 
-  /** Peek at upcoming tracks without modifying queue */
-  public peek(count: number = 5): Track[] {
-    return this.tracks.slice(0, count);
-  }
-
-  /** Remove a track at a specific index */
   public remove(index: number): Track | null {
     if (index < 0 || index >= this.tracks.length) return null;
     const [removed] = this.tracks.splice(index, 1);
     return removed;
   }
 
-  /** Clear all queued tracks (does not affect current) */
+  public removeRange(start: number, end: number): Track[] {
+    return this.tracks.splice(start, end - start);
+  }
+
   public clear(): void {
     this.tracks = [];
     this.current = null;
-    this.previous = null;
+    this.previous = [];
   }
 
-  // ─── Shuffle ──────────────────────────────────────────────────────
+  // ─── Reorder ──────────────────────────────────────────────────────
 
-  /** Fisher-Yates shuffle */
   public shuffle(): void {
     for (let i = this.tracks.length - 1; i > 0; i--) {
       const j = Math.floor(Math.random() * (i + 1));
@@ -49,34 +50,42 @@ export class Queue {
     }
   }
 
-  // ─── Move / Reorder ───────────────────────────────────────────────
-
-  /** Move a track from one position to another */
   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);
   }
 
-  // ─── Getters ──────────────────────────────────────────────────────
+  /** 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 ──────────────────────────────────────────────────
 
-  /** Total tracks in queue (not including current) */
-  get size(): number {
-    return this.tracks.length;
+  public peek(count: number = 10): Track[] {
+    return this.tracks.slice(0, count);
   }
 
-  /** Total duration of all queued tracks in ms */
-  get totalDuration(): number {
-    return this.tracks.reduce((acc, t) => acc + (t.info.length ?? 0), 0);
+  public find(predicate: (track: Track) => boolean): Track | undefined {
+    return this.tracks.find(predicate);
   }
 
-  /** Whether the queue is empty */
-  get isEmpty(): boolean {
-    return this.tracks.length === 0;
+  public filter(predicate: (track: Track) => boolean): Track[] {
+    return this.tracks.filter(predicate);
   }
 
-  /** All tracks as array (read-only view) */
-  get list(): ReadonlyArray<Track> {
-    return this.tracks;
+  // ─── 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; }
 }