@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

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

@@ -0,0 +1,606 @@
+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)
+        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'
+    )
+  }
+}