@therealtinhtute/baroiplayer 1.2.0 → 2.0.0-beta.1

package/src/features/playlist/playlist-manager.ts

@@ -1,626 +0,0 @@
-export interface PlaylistItem {
-	id: string
-	title: string
-	src: string
-	duration?: number
-	thumbnail?: string
-	metadata?: {
-		artist?: string
-		album?: string
-		genre?: string
-		year?: number
-		description?: string
-		tags?: string[]
-	}
-	subtitles?: SubtitleTrack[]
-	chapters?: ChapterMarker[]
-}
-
-export interface SubtitleTrack {
-	id: string
-	label: string
-	language: string
-	src: string
-	format: "vtt" | "srt"
-	default?: boolean
-}
-
-export interface ChapterMarker {
-	id: string
-	title: string
-	startTime: number
-	endTime?: number
-	thumbnail?: string
-}
-
-export interface PlaylistConfig {
-	shuffle?: boolean
-	repeat?: "none" | "one" | "all"
-	autoplay?: boolean
-	crossfade?: number
-	gapless?: boolean
-}
-
-export interface PlaylistEventData {
-	playlist?: PlaylistItem[]
-	currentItem?: PlaylistItem
-	currentIndex?: number
-	previousItem?: PlaylistItem
-	nextItem?: PlaylistItem
-}
-
-export type PlaylistEvent =
-	| "itemAdded"
-	| "itemRemoved"
-	| "itemChanged"
-	| "playlistChanged"
-	| "currentItemChanged"
-	| "configChanged"
-	| "shuffleChanged"
-	| "repeatChanged"
-
-export class PlaylistManager {
-	private items: PlaylistItem[] = []
-	private currentIndex: number = -1
-	private originalOrder: PlaylistItem[] = []
-	private config: PlaylistConfig = {
-		shuffle: false,
-		repeat: "none",
-		autoplay: true,
-		crossfade: 0,
-		gapless: false
-	}
-	private eventListeners: Map<PlaylistEvent, Set<Function>> = new Map()
-	private history: number[] = []
-	private historyIndex: number = -1
-
-	constructor(config?: Partial<PlaylistConfig>) {
-		if (config) {
-			this.updateConfig(config)
-		}
-	}
-
-	/**
-	 * Add item(s) to playlist
-	 */
-	add(items: PlaylistItem | PlaylistItem[], index?: number): void {
-		const itemsToAdd = Array.isArray(items) ? items : [items]
-
-		if (index !== undefined && index >= 0 && index <= this.items.length) {
-			this.items.splice(index, 0, ...itemsToAdd)
-			this.originalOrder.splice(index, 0, ...itemsToAdd)
-
-			// Adjust current index if needed
-			if (index <= this.currentIndex) {
-				this.currentIndex += itemsToAdd.length
-			}
-		} else {
-			this.items.push(...itemsToAdd)
-			this.originalOrder.push(...itemsToAdd)
-		}
-
-		// If this is the first item and no current item is set
-		if (this.currentIndex === -1 && this.items.length > 0) {
-			this.currentIndex = 0
-			this.addToHistory(0)
-		}
-
-		itemsToAdd.forEach((item) => {
-			this.emit("itemAdded", { currentItem: item, playlist: this.items })
-		})
-
-		this.emit("playlistChanged", { playlist: this.items })
-	}
-
-	/**
-	 * Remove item(s) from playlist
-	 */
-	remove(indices: number | number[]): PlaylistItem[] {
-		const indicesToRemove = Array.isArray(indices) ? indices.sort((a, b) => b - a) : [indices]
-		const removedItems: PlaylistItem[] = []
-
-		indicesToRemove.forEach((index) => {
-			if (index >= 0 && index < this.items.length) {
-				const [removedItem] = this.items.splice(index, 1)
-				if (removedItem) {
-					const originalIndex = this.originalOrder.findIndex((item) => item.id === removedItem.id)
-					if (originalIndex >= 0) {
-						this.originalOrder.splice(originalIndex, 1)
-					}
-
-					removedItems.push(removedItem)
-				}
-
-				// Adjust current index
-				if (index < this.currentIndex) {
-					this.currentIndex--
-				} else if (index === this.currentIndex) {
-					// If we removed the current item, stay at the same index
-					// (which now points to the next item)
-					if (this.currentIndex >= this.items.length) {
-						this.currentIndex = this.items.length - 1
-					}
-				}
-
-				this.emit("itemRemoved", { currentItem: removedItem, playlist: this.items })
-			}
-		})
-
-		// Update current index bounds
-		if (this.items.length === 0) {
-			this.currentIndex = -1
-			this.clearHistory()
-		} else if (this.currentIndex >= this.items.length) {
-			this.currentIndex = this.items.length - 1
-		}
-
-		this.emit("playlistChanged", { playlist: this.items })
-		return removedItems
-	}
-
-	/**
-	 * Move item to new position
-	 */
-	move(fromIndex: number, toIndex: number): boolean {
-		if (
-			fromIndex < 0 ||
-			fromIndex >= this.items.length ||
-			toIndex < 0 ||
-			toIndex >= this.items.length ||
-			fromIndex === toIndex
-		) {
-			return false
-		}
-
-		const [movedItem] = this.items.splice(fromIndex, 1)
-		if (!movedItem) return false
-		this.items.splice(toIndex, 0, movedItem)
-
-		// Update current index
-		if (fromIndex === this.currentIndex) {
-			this.currentIndex = toIndex
-		} else if (fromIndex < this.currentIndex && toIndex >= this.currentIndex) {
-			this.currentIndex--
-		} else if (fromIndex > this.currentIndex && toIndex <= this.currentIndex) {
-			this.currentIndex++
-		}
-
-		this.emit("playlistChanged", { playlist: this.items })
-		return true
-	}
-
-	/**
-	 * Clear all items
-	 */
-	clear(): void {
-		this.items = []
-		this.originalOrder = []
-		this.currentIndex = -1
-		this.clearHistory()
-		this.emit("playlistChanged", { playlist: this.items })
-	}
-
-	/**
-	 * Get current item
-	 */
-	getCurrentItem(): PlaylistItem | null {
-		return this.currentIndex >= 0 && this.currentIndex < this.items.length
-			? this.items[this.currentIndex] || null
-			: null
-	}
-
-	/**
-	 * Get current index
-	 */
-	getCurrentIndex(): number {
-		return this.currentIndex
-	}
-
-	/**
-	 * Set current item by index
-	 */
-	setCurrentIndex(index: number): boolean {
-		if (index >= 0 && index < this.items.length) {
-			const previousIndex = this.currentIndex
-			this.currentIndex = index
-			this.addToHistory(index)
-
-			this.emit("currentItemChanged", {
-				currentItem: this.items[index],
-				currentIndex: index,
-				previousItem: previousIndex >= 0 ? this.items[previousIndex] || undefined : undefined
-			})
-			return true
-		}
-		return false
-	}
-
-	/**
-	 * Set current item by ID
-	 */
-	setCurrentById(id: string): boolean {
-		const index = this.items.findIndex((item) => item.id === id)
-		return index >= 0 ? this.setCurrentIndex(index) : false
-	}
-
-	/**
-	 * Get next item
-	 */
-	getNext(): PlaylistItem | null {
-		const nextIndex = this.getNextIndex()
-		return nextIndex >= 0 && nextIndex < this.items.length ? this.items[nextIndex] || null : null
-	}
-
-	/**
-	 * Get previous item
-	 */
-	getPrevious(): PlaylistItem | null {
-		const prevIndex = this.getPreviousIndex()
-		return prevIndex >= 0 && prevIndex < this.items.length ? this.items[prevIndex] || null : null
-	}
-
-	/**
-	 * Move to next item
-	 */
-	next(): boolean {
-		const nextIndex = this.getNextIndex()
-		return nextIndex >= 0 ? this.setCurrentIndex(nextIndex) : false
-	}
-
-	/**
-	 * Move to previous item
-	 */
-	previous(): boolean {
-		// Check history first for better navigation
-		if (this.historyIndex > 0) {
-			this.historyIndex--
-			const histIndex = this.history[this.historyIndex]
-			if (histIndex !== undefined && histIndex >= 0 && histIndex < this.items.length) {
-				this.currentIndex = histIndex
-				this.emit("currentItemChanged", {
-					currentItem: this.items[this.currentIndex],
-					currentIndex: this.currentIndex
-				})
-				return true
-			}
-		}
-
-		const prevIndex = this.getPreviousIndex()
-		return prevIndex >= 0 ? this.setCurrentIndex(prevIndex) : false
-	}
-
-	/**
-	 * Get all items
-	 */
-	getItems(): PlaylistItem[] {
-		return [...this.items]
-	}
-
-	/**
-	 * Get item by index
-	 */
-	getItem(index: number): PlaylistItem | null {
-		return index >= 0 && index < this.items.length ? this.items[index] || null : null
-	}
-
-	/**
-	 * Get item by ID
-	 */
-	getItemById(id: string): PlaylistItem | null {
-		return this.items.find((item) => item.id === id) || null
-	}
-
-	/**
-	 * Find item index by ID
-	 */
-	findIndex(id: string): number {
-		return this.items.findIndex((item) => item.id === id)
-	}
-
-	/**
-	 * Get playlist length
-	 */
-	length(): number {
-		return this.items.length
-	}
-
-	/**
-	 * Check if playlist is empty
-	 */
-	isEmpty(): boolean {
-		return this.items.length === 0
-	}
-
-	/**
-	 * Toggle shuffle mode
-	 */
-	toggleShuffle(): boolean {
-		this.config.shuffle = !this.config.shuffle
-
-		if (this.config.shuffle) {
-			this.shufflePlaylist()
-		} else {
-			this.unshufflePlaylist()
-		}
-
-		this.emit("shuffleChanged", { playlist: this.items })
-		this.emit("configChanged", { playlist: this.items })
-		return this.config.shuffle
-	}
-
-	/**
-	 * Set repeat mode
-	 */
-	setRepeat(mode: "none" | "one" | "all"): void {
-		this.config.repeat = mode
-		this.emit("repeatChanged", { playlist: this.items })
-		this.emit("configChanged", { playlist: this.items })
-	}
-
-	/**
-	 * Update configuration
-	 */
-	updateConfig(config: Partial<PlaylistConfig>): void {
-		this.config = { ...this.config, ...config }
-		this.emit("configChanged", { playlist: this.items })
-	}
-
-	/**
-	 * Get configuration
-	 */
-	getConfig(): PlaylistConfig {
-		return { ...this.config }
-	}
-
-	/**
-	 * Add event listener
-	 */
-	addEventListener(event: PlaylistEvent, callback: Function): () => void {
-		if (!this.eventListeners.has(event)) {
-			this.eventListeners.set(event, new Set())
-		}
-
-		this.eventListeners.get(event)!.add(callback)
-
-		return () => {
-			const listeners = this.eventListeners.get(event)
-			if (listeners) {
-				listeners.delete(callback)
-			}
-		}
-	}
-
-	/**
-	 * Get next index based on current configuration
-	 */
-	private getNextIndex(): number {
-		if (this.items.length === 0) return -1
-
-		if (this.config.repeat === "one") {
-			return this.currentIndex
-		}
-
-		if (this.currentIndex < this.items.length - 1) {
-			return this.currentIndex + 1
-		}
-
-		if (this.config.repeat === "all") {
-			return 0
-		}
-
-		return -1
-	}
-
-	/**
-	 * Get previous index
-	 */
-	private getPreviousIndex(): number {
-		if (this.items.length === 0) return -1
-
-		if (this.config.repeat === "one") {
-			return this.currentIndex
-		}
-
-		if (this.currentIndex > 0) {
-			return this.currentIndex - 1
-		}
-
-		if (this.config.repeat === "all") {
-			return this.items.length - 1
-		}
-
-		return -1
-	}
-
-	/**
-	 * Shuffle playlist
-	 */
-	private shufflePlaylist(): void {
-		if (this.items.length <= 1) return
-
-		const currentItem = this.getCurrentItem()
-
-		// Fisher-Yates shuffle
-		for (let i = this.items.length - 1; i > 0; i--) {
-			const j = Math.floor(Math.random() * (i + 1))
-			const temp = this.items[i]
-			if (temp && this.items[j]) {
-				this.items[i] = this.items[j]
-				this.items[j] = temp
-			}
-		}
-
-		// Move current item to the beginning if it exists
-		if (currentItem) {
-			const currentItemIndex = this.items.findIndex((item) => item.id === currentItem.id)
-			if (currentItemIndex > 0) {
-				const temp = this.items[0]
-				if (temp && this.items[currentItemIndex]) {
-					this.items[0] = this.items[currentItemIndex]
-					this.items[currentItemIndex] = temp
-				}
-			}
-			this.currentIndex = 0
-		}
-	}
-
-	/**
-	 * Restore original order
-	 */
-	private unshufflePlaylist(): void {
-		const currentItem = this.getCurrentItem()
-		this.items = [...this.originalOrder]
-
-		if (currentItem) {
-			this.currentIndex = this.items.findIndex((item) => item.id === currentItem.id)
-		}
-	}
-
-	/**
-	 * Add to history
-	 */
-	private addToHistory(index: number): void {
-		// Remove any future history items
-		this.history = this.history.slice(0, this.historyIndex + 1)
-
-		// Add new index
-		this.history.push(index)
-		this.historyIndex = this.history.length - 1
-
-		// Limit history size
-		const maxHistory = 50
-		if (this.history.length > maxHistory) {
-			this.history = this.history.slice(-maxHistory)
-			this.historyIndex = this.history.length - 1
-		}
-	}
-
-	/**
-	 * Clear history
-	 */
-	private clearHistory(): void {
-		this.history = []
-		this.historyIndex = -1
-	}
-
-	/**
-	 * Emit events
-	 */
-	private emit(event: PlaylistEvent, data?: PlaylistEventData): void {
-		const listeners = this.eventListeners.get(event)
-		if (listeners) {
-			listeners.forEach((callback) => {
-				try {
-					callback(data)
-				} catch (error) {
-					console.error(`Error in playlist event listener for ${event}:`, error)
-				}
-			})
-		}
-	}
-
-	/**
-	 * Export playlist as JSON
-	 */
-	export(): string {
-		return JSON.stringify(
-			{
-				items: this.items,
-				currentIndex: this.currentIndex,
-				config: this.config
-			},
-			null,
-			2
-		)
-	}
-
-	/**
-	 * Import playlist from JSON
-	 */
-	import(jsonData: string): boolean {
-		try {
-			const data = JSON.parse(jsonData)
-
-			if (data.items && Array.isArray(data.items)) {
-				this.clear()
-				this.add(data.items)
-
-				if (typeof data.currentIndex === "number") {
-					this.setCurrentIndex(data.currentIndex)
-				}
-
-				if (data.config) {
-					this.updateConfig(data.config)
-				}
-
-				return true
-			}
-		} catch (error) {
-			console.error("Failed to import playlist:", error)
-		}
-
-		return false
-	}
-
-	/**
-	 * Create a new playlist from URLs
-	 */
-	static fromUrls(urls: string[], titleExtractor?: (url: string) => string): PlaylistManager {
-		const playlist = new PlaylistManager()
-		const items: PlaylistItem[] = urls.map((url, index) => ({
-			id: `item-${Date.now()}-${index}`,
-			title: titleExtractor ? titleExtractor(url) : `Media ${index + 1}`,
-			src: url
-		}))
-
-		playlist.add(items)
-		return playlist
-	}
-
-	/**
-	 * Cleanup resources
-	 */
-	destroy(): void {
-		this.clear()
-		this.eventListeners.clear()
-		this.clearHistory()
-	}
-}
-
-// Utility functions for playlist management
-export const playlistUtils = {
-	/**
-	 * Extract title from URL
-	 */
-	extractTitleFromUrl(url: string): string {
-		try {
-			const urlObj = new URL(url)
-			const pathname = urlObj.pathname
-			const filename = pathname.split("/").pop() || "Media"
-
-			// Remove file extension
-			return filename.split(".")[0] || "Media"
-		} catch {
-			return "Media"
-		}
-	},
-
-	/**
-	 * Generate unique ID
-	 */
-	generateId(): string {
-		return `playlist-item-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
-	},
-
-	/**
-	 * Validate playlist item
-	 */
-	validateItem(item: any): item is PlaylistItem {
-		return (
-			typeof item === "object" &&
-			typeof item.id === "string" &&
-			typeof item.title === "string" &&
-			typeof item.src === "string"
-		)
-	}
-}