@therealtinhtute/baroiplayer 1.0.8 → 1.1.0

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

@@ -1,606 +1,618 @@
 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[]
+	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
+	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
+	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
+	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
+	playlist?: PlaylistItem[]
+	currentItem?: PlaylistItem
+	currentIndex?: number
+	previousItem?: PlaylistItem
+	nextItem?: PlaylistItem
 }
 
-export type PlaylistEvent = 
-  | 'itemAdded'
-  | 'itemRemoved' 
-  | 'itemChanged'
-  | 'playlistChanged'
-  | 'currentItemChanged'
-  | 'configChanged'
-  | 'shuffleChanged'
-  | 'repeatChanged'
+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)
-        const [originalItem] = this.originalOrder.splice(
-          this.originalOrder.findIndex(item => item.id === removedItem.id), 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)
-    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
-  }
-
-  /**
-   * 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
-      })
-      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 ? this.items[nextIndex] : null
-  }
-
-  /**
-   * Get previous item
-   */
-  getPrevious(): PlaylistItem | null {
-    const prevIndex = this.getPreviousIndex()
-    return prevIndex >= 0 ? this.items[prevIndex] : 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 historyIndex = this.history[this.historyIndex]
-      if (historyIndex >= 0 && historyIndex < this.items.length) {
-        this.currentIndex = historyIndex
-        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
-  }
-
-  /**
-   * 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))
-      ;[this.items[i], this.items[j]] = [this.items[j], this.items[i]]
-    }
-    
-    // Move current item to the beginning if it exists
-    if (currentItem) {
-      const currentItemIndex = this.items.findIndex(item => item.id === currentItem.id)
-      if (currentItemIndex > 0) {
-        ;[this.items[0], this.items[currentItemIndex]] = [this.items[currentItemIndex], this.items[0]]
-      }
-      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()
-  }
+	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)
+				const [originalItem] = this.originalOrder.splice(
+					this.originalOrder.findIndex((item) => item.id === removedItem.id),
+					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)
+		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
+	}
+
+	/**
+	 * 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
+			})
+			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 ? this.items[nextIndex] : null
+	}
+
+	/**
+	 * Get previous item
+	 */
+	getPrevious(): PlaylistItem | null {
+		const prevIndex = this.getPreviousIndex()
+		return prevIndex >= 0 ? this.items[prevIndex] : 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 historyIndex = this.history[this.historyIndex]
+			if (historyIndex >= 0 && historyIndex < this.items.length) {
+				this.currentIndex = historyIndex
+				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
+	}
+
+	/**
+	 * 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))
+			;[this.items[i], this.items[j]] = [this.items[j], this.items[i]]
+		}
+
+		// Move current item to the beginning if it exists
+		if (currentItem) {
+			const currentItemIndex = this.items.findIndex((item) => item.id === currentItem.id)
+			if (currentItemIndex > 0) {
+				;[this.items[0], this.items[currentItemIndex]] = [
+					this.items[currentItemIndex],
+					this.items[0]
+				]
+			}
+			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'
-    )
-  }
-}
+	/**
+	 * 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"
+		)
+	}
+}