@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

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

@@ -0,0 +1,475 @@
+export class PlaylistManager {
+    items = [];
+    currentIndex = -1;
+    originalOrder = [];
+    config = {
+        shuffle: false,
+        repeat: 'none',
+        autoplay: true,
+        crossfade: 0,
+        gapless: false
+    };
+    eventListeners = new Map();
+    history = [];
+    historyIndex = -1;
+    constructor(config) {
+        if (config) {
+            this.updateConfig(config);
+        }
+    }
+    /**
+     * Add item(s) to playlist
+     */
+    add(items, index) {
+        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) {
+        const indicesToRemove = Array.isArray(indices) ? indices.sort((a, b) => b - a) : [indices];
+        const removedItems = [];
+        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, toIndex) {
+        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() {
+        this.items = [];
+        this.originalOrder = [];
+        this.currentIndex = -1;
+        this.clearHistory();
+        this.emit('playlistChanged', { playlist: this.items });
+    }
+    /**
+     * Get current item
+     */
+    getCurrentItem() {
+        return this.currentIndex >= 0 && this.currentIndex < this.items.length
+            ? this.items[this.currentIndex]
+            : null;
+    }
+    /**
+     * Get current index
+     */
+    getCurrentIndex() {
+        return this.currentIndex;
+    }
+    /**
+     * Set current item by index
+     */
+    setCurrentIndex(index) {
+        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) {
+        const index = this.items.findIndex(item => item.id === id);
+        return index >= 0 ? this.setCurrentIndex(index) : false;
+    }
+    /**
+     * Get next item
+     */
+    getNext() {
+        const nextIndex = this.getNextIndex();
+        return nextIndex >= 0 ? this.items[nextIndex] : null;
+    }
+    /**
+     * Get previous item
+     */
+    getPrevious() {
+        const prevIndex = this.getPreviousIndex();
+        return prevIndex >= 0 ? this.items[prevIndex] : null;
+    }
+    /**
+     * Move to next item
+     */
+    next() {
+        const nextIndex = this.getNextIndex();
+        return nextIndex >= 0 ? this.setCurrentIndex(nextIndex) : false;
+    }
+    /**
+     * Move to previous item
+     */
+    previous() {
+        // 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() {
+        return [...this.items];
+    }
+    /**
+     * Get item by index
+     */
+    getItem(index) {
+        return index >= 0 && index < this.items.length ? this.items[index] : null;
+    }
+    /**
+     * Get item by ID
+     */
+    getItemById(id) {
+        return this.items.find(item => item.id === id) || null;
+    }
+    /**
+     * Find item index by ID
+     */
+    findIndex(id) {
+        return this.items.findIndex(item => item.id === id);
+    }
+    /**
+     * Get playlist length
+     */
+    length() {
+        return this.items.length;
+    }
+    /**
+     * Check if playlist is empty
+     */
+    isEmpty() {
+        return this.items.length === 0;
+    }
+    /**
+     * Toggle shuffle mode
+     */
+    toggleShuffle() {
+        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) {
+        this.config.repeat = mode;
+        this.emit('repeatChanged', { playlist: this.items });
+        this.emit('configChanged', { playlist: this.items });
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        this.emit('configChanged', { playlist: this.items });
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Add event listener
+     */
+    addEventListener(event, callback) {
+        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
+     */
+    getNextIndex() {
+        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
+     */
+    getPreviousIndex() {
+        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
+     */
+    shufflePlaylist() {
+        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
+     */
+    unshufflePlaylist() {
+        const currentItem = this.getCurrentItem();
+        this.items = [...this.originalOrder];
+        if (currentItem) {
+            this.currentIndex = this.items.findIndex(item => item.id === currentItem.id);
+        }
+    }
+    /**
+     * Add to history
+     */
+    addToHistory(index) {
+        // 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
+     */
+    clearHistory() {
+        this.history = [];
+        this.historyIndex = -1;
+    }
+    /**
+     * Emit events
+     */
+    emit(event, data) {
+        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() {
+        return JSON.stringify({
+            items: this.items,
+            currentIndex: this.currentIndex,
+            config: this.config
+        }, null, 2);
+    }
+    /**
+     * Import playlist from JSON
+     */
+    import(jsonData) {
+        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, titleExtractor) {
+        const playlist = new PlaylistManager();
+        const items = 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() {
+        this.clear();
+        this.eventListeners.clear();
+        this.clearHistory();
+    }
+}
+// Utility functions for playlist management
+export const playlistUtils = {
+    /**
+     * Extract title from URL
+     */
+    extractTitleFromUrl(url) {
+        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() {
+        return `playlist-item-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    },
+    /**
+     * Validate playlist item
+     */
+    validateItem(item) {
+        return (typeof item === 'object' &&
+            typeof item.id === 'string' &&
+            typeof item.title === 'string' &&
+            typeof item.src === 'string');
+    }
+};