ziplayer 0.2.5 → 0.2.6

package/src/plugins/index.ts

@@ -3,7 +3,6 @@ import { withTimeout } from "../utils/timeout";
 import type { Track, StreamInfo } from "../types";
 import type { PlayerManager } from "../structures/PlayerManager";
 import type { Player } from "../structures/Player";
-type DebugFn = (message?: any, ...optionalParams: any[]) => void;
 
 type PluginManagerOptions = {
 	extractorTimeout: number | undefined;
@@ -13,7 +12,6 @@ export { BasePlugin } from "./BasePlugin";
 
 // Plugin factory
 export class PluginManager {
-	private debug: DebugFn;
 	private options: PluginManagerOptions;
 	private player: Player;
 	private manager: PlayerManager;
@@ -23,11 +21,12 @@ export class PluginManager {
 		this.player = player;
 		this.manager = manager;
 		this.options = options;
-		this.debug = (message?: any, ...optionalParams: any[]) => {
-			if (manager.debugEnabled) {
-				manager.emit("debug", `[ExtensionManager] ${message}`, ...optionalParams);
-			}
-		};
+	}
+
+	debug(message?: any, ...optionalParams: any[]): void {
+		if (this.manager.debugEnabled) {
+			this.manager.emit("debug", `[Plugins] ${message}`, ...optionalParams);
+		}
 	}
 
 	register(plugin: BasePlugin): void {
@@ -55,55 +54,183 @@ export class PluginManager {
 	}
 
 	async getStream(track: Track): Promise<StreamInfo | null> {
-		let streamInfo: StreamInfo | null = null;
-		const plugin = this.get(track.source) || this.findPlugin(track.url);
-
-		if (!plugin) {
-			this.debug(`[Player] No plugin found for track: ${track.title}`);
+		const timeoutMs = this.options.extractorTimeout ?? 50000;
+		const primary = this.get(track.source) || this.findPlugin(track.url);
+		if (!primary) {
+			this.debug(`No plugin found for track: ${track.title}`);
 			return null;
 		}
-
-		this.debug(`[Player] Getting stream for track: ${track.title}`);
-		this.debug(`[Player] Using plugin: ${plugin.name}`);
-		this.debug(`[Track] Track Info:`, track);
-		const timeoutMs = this.options.extractorTimeout ?? 50000;
 		try {
-			streamInfo = await withTimeout(plugin.getStream(track), timeoutMs, "getStream timed out");
-			if (!(streamInfo as any)?.stream) {
-				throw new Error(`No stream returned from ${plugin.name}`);
-			}
-		} catch (streamError) {
-			this.debug(`[Player] getStream failed, trying getFallback:`, streamError);
-			const allplugs = this.getAll();
-			for (const p of allplugs) {
-				try {
-					if (typeof p.getStream == "function") {
-						streamInfo = await withTimeout((p as any).getStream(track), timeoutMs, `getStream timed out for plugin ${p.name}`);
-						if ((streamInfo as any)?.stream) {
-							this.debug(`[Player] getStream succeeded with plugin ${p.name} for track: ${track.title}`);
-							return streamInfo as StreamInfo;
-						}
-					}
-					if (typeof p.getFallback == "function") {
-						streamInfo = await withTimeout(
-							(p as any).getFallback(track),
-							timeoutMs,
-							`getFallback timed out for plugin ${p.name}`,
-						);
-						if ((streamInfo as any)?.stream) {
-							this.debug(`[Player] getFallback succeeded with plugin ${p.name} for track: ${track.title}`);
-							return streamInfo as StreamInfo;
+			const controller = new AbortController();
+			const result = await withTimeout(primary.getStream(track, controller.signal), timeoutMs, "Primary timeout");
+			if (result?.stream) return result;
+			throw new Error("Primary failed");
+		} catch {
+			this.debug("Primary failed → fallback parallel");
+		}
+
+		// ===== FALLBACK PARALLEL =====
+		const plugins = this.getAll()
+			.filter((p) => p !== primary)
+			.map((p) => {
+				p.priority ??= 0;
+				return p;
+			})
+			.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+
+		// group by priority
+		const groups = new Map<number, BasePlugin[]>();
+		for (const p of plugins) {
+			if (!groups.has(p.priority ?? 0)) groups.set(p.priority ?? 0, []);
+			groups.get(p.priority ?? 0)!.push(p);
+		}
+		for (const [priority, group] of groups) {
+			this.debug(`Running group priority=${priority}`);
+			const controller = new AbortController();
+			try {
+				const promises = group.map((p) => {
+					const run = async () => {
+						try {
+							let result: StreamInfo | null = null;
+
+							if (p.getStream) {
+								try {
+									result = await withTimeout(p.getStream(track, controller.signal), timeoutMs, `Timeout ${p.name}`);
+								} catch (err) {
+									// getStream thất bại → log rồi thử getFallback
+									this.debug(`getStream failed for ${p.name}, trying getFallback`, err);
+								}
+
+								if (result?.stream) {
+									this.debug(`Success via ${p.name}`);
+									controller.abort();
+									return result;
+								}
+							}
+
+							if (p.getFallback) {
+								result = await withTimeout(p.getFallback(track, controller.signal), timeoutMs, `Fallback timeout ${p.name}`);
+								if (result?.stream) {
+									this.debug(`Fallback via ${p.name}`);
+									controller.abort();
+									return result;
+								}
+							}
+
+							throw new Error("No stream");
+						} catch (err) {
+							if (controller.signal.aborted) throw new Error("Aborted");
+							this.debug(`Failed ${p.name}`, err);
+							throw err;
 						}
-					}
-				} catch (fallbackError) {
-					this.debug(`[Player] getFallback failed with plugin ${p.name}:`, fallbackError);
+					};
+					return run();
+				});
+
+				const result = await Promise.any(promises);
+				if (result?.stream) return result;
+			} catch {
+				this.debug(`Priority group ${priority} failed`);
+				controller.abort();
+			}
+		}
+
+		throw new Error(`All plugins failed for track: ${track.title}`);
+	}
+
+	/**
+	 * Get related tracks for a given track
+	 * @param {Track} track Track to find related tracks for
+	 * @returns {Track[]} Related tracks or empty array
+	 * @example
+	 * const related = await player.getRelatedTracks(track);
+	 * console.log(`Found ${related.length} related tracks`);
+	 */
+	async getRelatedTracks(track: Track): Promise<Track[]> {
+		if (!track) return [];
+
+		const timeoutMs = this.options.extractorTimeout ?? 15000;
+		const preferred = this.findPlugin(track.url) || this.get(track.source);
+
+		// ===== THỬ PREFERRED TRƯỚC =====
+		if (preferred && typeof preferred.getRelatedTracks === "function") {
+			try {
+				this.debug(`[RelatedTracks] Trying preferred: ${preferred.name}`);
+				const related = await withTimeout(
+					preferred.getRelatedTracks(track, {
+						limit: 10,
+						history: this.player.queue.previousTracks,
+					}),
+					timeoutMs,
+					`getRelatedTracks timed out for ${preferred.name}`,
+				);
+
+				if (Array.isArray(related) && related.length > 0) {
+					return related;
 				}
+				this.debug(`[RelatedTracks] ${preferred.name} returned no results → fallback race`);
+			} catch (err) {
+				this.debug(`[RelatedTracks] ${preferred.name} failed → fallback race`, err);
 			}
-			if (!(streamInfo as any)?.stream) {
-				throw new Error(`All getFallback attempts failed for track: ${track.title}`);
+		}
+
+		// ===== FALLBACK: RACE THEO PRIORITY GROUP =====
+		const plugins = this.getAll()
+			.filter((p) => p !== preferred && typeof p.getRelatedTracks === "function")
+			.map((p) => {
+				p.priority ??= 0;
+				return p;
+			})
+			.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+
+		// group by priority
+		const groups = new Map<number, BasePlugin[]>();
+		for (const p of plugins) {
+			const key = p.priority ?? 0;
+			if (!groups.has(key)) groups.set(key, []);
+			groups.get(key)!.push(p);
+		}
+
+		for (const [priority, group] of groups) {
+			this.debug(`[RelatedTracks] Racing priority=${priority} (${group.map((p) => p.name).join(", ")})`);
+			const controller = new AbortController();
+
+			try {
+				const promises = group.map((p) =>
+					(async () => {
+						try {
+							const related = await withTimeout(
+								p.getRelatedTracks!(track, {
+									limit: 10,
+									history: this.player.queue.previousTracks,
+								}),
+								timeoutMs,
+								`getRelatedTracks timed out for ${p.name}`,
+							);
+
+							if (Array.isArray(related) && related.length > 0) {
+								this.debug(`[RelatedTracks] Success via ${p.name}`);
+								controller.abort();
+								return related;
+							}
+							throw new Error(`${p.name} returned no results`);
+						} catch (err) {
+							if (controller.signal.aborted) throw new Error("Aborted");
+							this.debug(`[RelatedTracks] ${p.name} failed`, err);
+							throw err;
+						}
+					})(),
+				);
+
+				const result = await Promise.any(promises);
+				if (result) return result;
+			} catch {
+				this.debug(`[RelatedTracks] Priority group ${priority} all failed`);
+				controller.abort();
 			}
 		}
 
-		return streamInfo as StreamInfo;
+		this.debug(`[RelatedTracks] All plugins failed for: ${track.title}`);
+		return [];
 	}
 }

package/src/structures/Player.ts

@@ -165,18 +165,15 @@ export class Player extends EventEmitter {
 	 * @private
 	 */
 	private destroyCurrentStream(): void {
-		try {
-			// Get the metadata from current resource to find the stream
-			if (this.currentResource) {
-				const stream = (this.currentResource as any)?.metadata?.stream || (this.currentResource as any)?.stream;
-				if (stream && typeof stream.destroy === "function") {
-					stream.destroy();
-					this.debug(`[Player] Destroyed current stream`);
-				}
-			}
-		} catch (error) {
-			this.debug(`[Player] Error destroying current stream:`, error);
+		if (!this.currentResource) return;
+
+		const stream = (this.currentResource as any)?.metadata?.stream ?? (this.currentResource as any)?.stream;
+
+		if (stream?.destroy) {
+			stream.destroy();
 		}
+
+		this.currentResource = null;
 	}
 
 	//#region Search
@@ -354,54 +351,10 @@ export class Player extends EventEmitter {
 		};
 	}
 
-	/**
-	 * Get related tracks for a given track
-	 * @param {Track} track Track to find related tracks for
-	 * @returns {Track[]} Related tracks or empty array
-	 * @example
-	 * const related = await player.getRelatedTracks(track);
-	 * console.log(`Found ${related.length} related tracks`);
-	 */
-	async getRelatedTracks(track: Track): Promise<Track[]> {
-		if (!track) return [];
-
-		const preferred = this.pluginManager.findPlugin(track.url) || this.pluginManager.get(track.source);
-
-		const all = this.pluginManager.getAll();
-
-		const candidates = [...(preferred ? [preferred] : []), ...all.filter((p) => p !== preferred)].filter(
-			(p) => typeof (p as any).getRelatedTracks === "function",
-		);
-
-		for (const p of candidates) {
-			try {
-				this.debug(`[Player] Trying related from plugin: ${p.name}`);
-				const related = await withTimeout(
-					(p as any).getRelatedTracks(track.url, {
-						limit: 10,
-						history: this.queue.previousTracks,
-					}),
-					this.options.extractorTimeout ?? 15000,
-					`getRelatedTracks timed out for ${p.name}`,
-				);
-
-				if (Array.isArray(related) && related.length > 0) {
-					return related; // success
-				}
-				this.debug(`[Player] ${p.name} returned no related tracks`);
-			} catch (err) {
-				this.debug(`[Player] getRelatedTracks error from ${p.name}:`, err);
-				return [];
-				// try next candidate
-			}
-		}
-		return [];
-	}
-
 	private async generateWillNext(): Promise<void> {
 		const lastTrack = this.queue.previousTracks[this.queue.previousTracks.length - 1] ?? this.queue.currentTrack;
 		if (!lastTrack) return;
-		const related = await this.getRelatedTracks(lastTrack);
+		const related = await this.pluginManager.getRelatedTracks(lastTrack);
 		if (!related || related.length === 0) return;
 		const randomchoice = Math.floor(Math.random() * related.length);
 		const nextTrack = this.queue.nextTrack ? this.queue.nextTrack : related[randomchoice];
@@ -646,15 +599,6 @@ export class Player extends EventEmitter {
 				try {
 					// Destroy the old stream and resource before creating a new one
 					this.destroyCurrentStream();
-					if (this.currentResource) {
-						try {
-							const oldStream = (this.currentResource as any)._readableState?.stream || (this.currentResource as any).stream;
-							if (oldStream && typeof oldStream.destroy === "function") {
-								oldStream.destroy();
-							}
-						} catch {}
-						this.currentResource = null;
-					}
 
 					this.currentResource = await this.createResource(streamInfo, track, 0);
 					if (this.volumeInterval) {
@@ -710,39 +654,41 @@ export class Player extends EventEmitter {
 	}
 
 	private async playNext(): Promise<boolean> {
-		this.debug(`[Player] playNext called`);
-		const track = this.queue.next(this.skipLoop);
-		this.skipLoop = false;
-		if (!track) {
-			if (this.queue.autoPlay()) {
-				const willnext = this.queue.willNextTrack();
-				if (willnext) {
-					this.debug(`[Player] Auto-playing next track: ${willnext.title}`);
-					this.queue.addMultiple([willnext]);
-					return this.playNext();
+		this.debug(`[Player] playNext called by ${new Error().stack?.split("\n")[2]?.trim()}`);
+		while (true) {
+			const track = this.queue.next(this.skipLoop);
+			this.skipLoop = false;
+
+			if (!track) {
+				if (this.queue.autoPlay()) {
+					const willnext = this.queue.willNextTrack();
+					if (willnext) {
+						this.queue.addMultiple([willnext]);
+						continue;
+					}
 				}
-			}
+				this.debug(`[Player] No next track in queue`);
+				this.isPlaying = false;
+				this.emit("queueEnd");
 
-			this.debug(`[Player] No next track in queue`);
-			this.isPlaying = false;
-			this.emit("queueEnd");
+				if (this.options.leaveOnEnd) {
+					this.scheduleLeave();
+				}
 
-			if (this.options.leaveOnEnd) {
-				this.scheduleLeave();
+				return false;
 			}
-			return false;
-		}
-
-		this.generateWillNext();
-		// A new track is about to play; ensure we don't leave mid-playback
-		this.clearLeaveTimeout();
 
-		try {
-			return await this.startTrack(track);
-		} catch (error) {
-			this.debug(`[Player] playNext error:`, error);
-			this.emit("playerError", error as Error, track);
-			return this.playNext();
+			this.generateWillNext();
+			this.clearLeaveTimeout();
+			this.debug(`[Player] playNext called for track: ${track.title}`);
+			
+			try {
+				return await this.startTrack(track);
+			} catch (err) {
+				this.debug(`[Player] playNext error:`, err);
+				this.emit("playerError", err as Error, track);
+				continue;
+			}
 		}
 	}
 

package/src/types/plugin.ts

@@ -6,15 +6,17 @@ import type { SearchResult, StreamInfo, Track } from ".";
  * const plugin: SourcePlugin = {
  *   name: "YouTube",
  *   version: "1.0.0"
+ *   priority: 0, // Optional, default is 0. Lower priority plugins are tried first in getStream fallback.
  * };
  */
 export interface SourcePlugin {
 	name: string;
 	version: string;
+	priority?: number;
 	canHandle(query: string): boolean;
 	search(query: string, requestedBy: string): Promise<SearchResult>;
 	getStream(track: Track): Promise<StreamInfo>;
-	getRelatedTracks?(track: string | number, opts?: { limit?: number; offset?: number }): Promise<Track[]>;
+	getRelatedTracks?(track: Track, opts?: { limit?: number; offset?: number }): Promise<Track[]>;
 	validate?(url: string): boolean;
 	extractPlaylist?(url: string, requestedBy: string): Promise<Track[]>;
 }

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
 	"compilerOptions": {
-		"target": "ES2020",
+		"target": "es2021",
 		"module": "commonjs",
-		"lib": ["ES2020"],
+		"lib": ["ES2021"],
 		"outDir": "./dist",
 		"rootDir": "./src",
 		"strict": true,