yukimu 1.2.0 → 1.3.0

package/src/connector/Oceanic.ts

@@ -1,27 +1,17 @@
 import { Connector } from "./Connector";
-import type { Yukimu } from "../Yukimu";
-
-interface OceanicClient {
-  guilds: Map<string, { shard: { send(payload: unknown): void } }>;
-  on(event: "packet", listener: (packet: { t: string; d: unknown }) => void): this;
-}
 
 export class Oceanic extends Connector {
-  private client: OceanicClient;
+  private client: any;
 
-  constructor(client: OceanicClient) {
+  constructor(client: any) {
     super();
     this.client = client;
   }
 
   public listen(): void {
-    this.client.on("packet", (packet: { t: string; d: unknown }) => {
-      if (packet.t === "VOICE_STATE_UPDATE") {
-        this.manager.handleVoiceStateUpdate(packet.d as Parameters<Yukimu["handleVoiceStateUpdate"]>[0]);
-      }
-      if (packet.t === "VOICE_SERVER_UPDATE") {
-        this.manager.handleVoiceServerUpdate(packet.d as Parameters<Yukimu["handleVoiceServerUpdate"]>[0]);
-      }
+    this.client.on("packet", (packet: any) => {
+      if (packet.t === "VOICE_STATE_UPDATE") this.manager.handleVoiceStateUpdate(packet.d);
+      if (packet.t === "VOICE_SERVER_UPDATE") this.manager.handleVoiceServerUpdate(packet.d);
     });
   }
 

package/src/errors/YukimuError.ts

@@ -22,12 +22,10 @@ export class PlayerError extends YukimuError {
 export class RestError extends YukimuError {
   public readonly status: number;
   public readonly path: string;
-
   constructor(message: string, status: number, path: string) {
     super(message);
     this.name = "RestError";
     this.status = status;
-    this.status = status;
     this.path = path;
   }
 }

package/src/index.ts

@@ -1,4 +1,3 @@
-// Core
 export { Yukimu } from "./Yukimu";
 export { Node } from "./Node";
 export { Player } from "./Player";
@@ -9,38 +8,17 @@ export { ConnectionPool } from "./ConnectionPool";
 export { TrackCache } from "./TrackCache";
 export { WsQueue } from "./WsQueue";
 export { Plugin } from "./Plugin";
-
-// Connectors
 export { Connector } from "./connector/Connector";
 export { DiscordJS } from "./connector/DiscordJS";
 export { Eris } from "./connector/Eris";
 export { Oceanic } from "./connector/Oceanic";
-
-// Built-in Plugins
 export { PlayerMoved } from "./plugins/PlayerMoved";
 export { AutoResume } from "./plugins/AutoResume";
-
-// Errors
 export { YukimuError, NodeError, PlayerError, RestError } from "./errors/YukimuError";
-
-// Constants (enums)
 export * from "./Constants";
-
-// Types — export individually to avoid conflicts with Constants
 export type {
-  YukimuOptions,
-  NodeOptions,
-  NodeStats,
-  NodeInfo,
-  PlayerOptions,
-  SpotifyOptions,
-  SearchSource,
-  Track,
-  TrackInfo,
-  SearchResult,
-  PlaylistInfo,
-  LavalinkException,
-  VoiceState,
-  FilterOptions,
-  YukimuEvents,
+  YukimuOptions, NodeOptions, NodeStats, NodeInfo,
+  PlayerOptions, SpotifyOptions, SearchSource,
+  Track, TrackInfo, SearchResult, PlaylistInfo,
+  LavalinkException, VoiceState, FilterOptions, YukimuEvents,
 } from "./types";

package/src/plugins/AutoResume.ts

@@ -1,30 +1,24 @@
 import { Plugin } from "../Plugin";
 import type { Yukimu } from "../Yukimu";
-import type { Player } from "../Player";
-import type { Node } from "../Node";
-import type { Track } from "../types";
-
-interface SavedState {
-  guildId: string;
-  voiceChannelId: string;
-  textChannelId?: string;
-  volume: number;
-  loop: "none" | "track" | "queue";
-  position: number;
-  trackEncoded?: string;
-  data: [string, unknown][];
-}
 
 export class AutoResume extends Plugin {
   public name = "AutoResume";
-  private states: Map<string, SavedState> = new Map();
+  private states: Map<string, any> = new Map();
 
   public load(manager: Yukimu): void {
-    manager.on("trackStart", (player: Player, track: Track) => {
-      this.save(player);
+    manager.on("trackStart", (player: any, track: any) => {
+      if (!player.queue.current) return;
+      this.states.set(player.guildId, {
+        guildId: player.guildId,
+        voiceChannelId: player.voiceChannelId,
+        volume: player.volume,
+        loop: player.loop,
+        position: player.position,
+        trackEncoded: player.queue.current.encoded,
+      });
     });
 
-    manager.on("nodeReady", async (node: Node) => {
+    manager.on("nodeReady", async (node: any) => {
       if (!node.resumed) return;
       for (const [guildId, state] of this.states) {
         const player = manager.players.get(guildId);
@@ -36,26 +30,8 @@ export class AutoResume extends Plugin {
       }
     });
 
-    manager.on("playerDestroy", (player: Player) => {
+    manager.on("playerDestroy", (player: any) => {
       this.states.delete(player.guildId);
     });
   }
-
-  private save(player: Player): void {
-    if (!player.queue.current) return;
-    this.states.set(player.guildId, {
-      guildId: player.guildId,
-      voiceChannelId: player.voiceChannelId!,
-      textChannelId: player.textChannelId,
-      volume: player.volume,
-      loop: player.loop,
-      position: player.position,
-      trackEncoded: player.queue.current.encoded,
-      data: [...player.data.entries()],
-    });
-  }
-
-  public getSavedState(guildId: string): SavedState | undefined {
-    return this.states.get(guildId);
-  }
 }

package/src/plugins/PlayerMoved.ts

@@ -5,9 +5,9 @@ export class PlayerMoved extends Plugin {
   public name = "PlayerMoved";
 
   public load(manager: Yukimu): void {
-    manager.on("playerMove", async (player, oldChannel, newChannel) => {
+    manager.on("playerMove", async (player: any, oldChannel: string, newChannel: string) => {
       if (!newChannel) {
-        if ((manager.options as any).moveOnDisconnect) {
+        if (manager.options.moveOnDisconnect) {
           await manager.destroyPlayer(player.guildId).catch(() => {});
         }
         return;
@@ -15,9 +15,9 @@ export class PlayerMoved extends Plugin {
       player.voiceChannelId = newChannel;
     });
 
-    manager.on("socketClosed", async (player, code, reason, byRemote) => {
+    manager.on("socketClosed", async (player: any, code: number, reason: string, byRemote: boolean) => {
       if (code === 4014 || code === 4006) {
-        if ((manager.options as any).moveOnDisconnect) {
+        if (manager.options.moveOnDisconnect) {
           await manager.destroyPlayer(player.guildId).catch(() => {});
         }
       }

package/src/types.ts

@@ -31,8 +31,8 @@ export type SearchSource =
 export interface Track {
   encoded: string;
   info: TrackInfo;
-  pluginInfo?: Record<string, unknown>;
-  requester?: unknown;
+  pluginInfo?: Record<string, any>;
+  requester?: any;
 }
 
 export interface TrackInfo {
@@ -55,11 +55,10 @@ export interface SearchResult {
   tracks: Track[];
   playlistInfo?: PlaylistInfo;
   exception?: LavalinkException;
-  pluginInfo?: Record<string, unknown>;
+  pluginInfo?: Record<string, any>;
+  data?: any;
 }
 
-import { LoadType } from "./Constants";
-
 export interface PlaylistInfo {
   name: string;
   selectedTrack: number;
@@ -70,7 +69,7 @@ export interface PlaylistInfo {
 
 export interface LavalinkException {
   message?: string;
-  severity: "common" | "suspicious" | "fault";
+  severity: string;
   cause: string;
 }
 
@@ -88,6 +87,7 @@ export interface VoiceState {
   token: string;
   endpoint: string;
   sessionId: string;
+  channelId?: string;
 }
 
 export interface NodeStats {
@@ -100,7 +100,7 @@ export interface NodeStats {
 }
 
 export interface NodeInfo {
-  version: { semver: string; major: number; minor: number; patch: number; preRelease?: string; build?: string };
+  version: { semver: string; major: number; minor: number; patch: number };
   buildTime: number;
   git: { branch: string; commit: string; commitTime: number };
   jvm: string;
@@ -117,29 +117,29 @@ export interface FilterOptions {
   tremolo?: { frequency?: number; depth?: number };
   vibrato?: { frequency?: number; depth?: number };
   rotation?: { rotationHz?: number };
-  distortion?: { sinOffset?: number; sinScale?: number; cosOffset?: number; cosScale?: number; tanOffset?: number; tanScale?: number; offset?: number; scale?: number };
+  distortion?: any;
   channelMix?: { leftToLeft?: number; leftToRight?: number; rightToLeft?: number; rightToRight?: number };
   lowPass?: { smoothing?: number };
   volume?: number;
-  [key: string]: unknown;
+  [key: string]: any;
 }
 
 export type YukimuEvents = {
-  nodeConnecting: [node: import("./Node").Node];
-  nodeConnect: [node: import("./Node").Node];
-  nodeReady: [node: import("./Node").Node];
-  nodeDisconnect: [node: import("./Node").Node, code: number, reason: string];
-  nodeError: [node: import("./Node").Node, error: Error];
-  trackStart: [player: import("./Player").Player, track: Track];
-  trackEnd: [player: import("./Player").Player, track: Track, reason: string];
-  trackError: [player: import("./Player").Player, track: Track, exception: LavalinkException];
-  trackStuck: [player: import("./Player").Player, track: Track, threshold: number];
-  playerCreate: [player: import("./Player").Player];
-  playerDestroy: [player: import("./Player").Player];
-  playerUpdate: [player: import("./Player").Player];
-  playerMove: [player: import("./Player").Player, oldChannel: string, newChannel: string];
-  playerError: [player: import("./Player").Player, error: Error];
-  queueEnd: [player: import("./Player").Player];
-  autoplayRequest: [player: import("./Player").Player, track: Track];
-  socketClosed: [player: import("./Player").Player, code: number, reason: string, byRemote: boolean];
+  nodeConnecting: [node: any];
+  nodeConnect: [node: any];
+  nodeReady: [node: any];
+  nodeDisconnect: [node: any, code: number, reason: string];
+  nodeError: [node: any, error: Error];
+  trackStart: [player: any, track: Track];
+  trackEnd: [player: any, track: Track, reason: string];
+  trackError: [player: any, track: Track, exception: LavalinkException];
+  trackStuck: [player: any, track: Track, threshold: number];
+  playerCreate: [player: any];
+  playerDestroy: [player: any];
+  playerUpdate: [player: any];
+  playerMove: [player: any, oldChannel: string, newChannel: string];
+  playerError: [player: any, error: Error];
+  queueEnd: [player: any];
+  autoplayRequest: [player: any, track: Track];
+  socketClosed: [player: any, code: number, reason: string, byRemote: boolean];
 };

package/tsconfig.json

@@ -13,7 +13,9 @@
     "sourceMap": true,
     "resolveJsonModule": true,
     "forceConsistentCasingInFileNames": true,
-    "noImplicitAny": false
+    "noImplicitAny": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "example"]