@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

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

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