tunecamp 1.0.0

package/templates/retro/assets/download-stats.js

@@ -0,0 +1,263 @@
+/**
+ * Tunecamp Download Stats - GunDB Client
+ * Decentralized download counter using GunDB public peers
+ * 
+ * Uses a public GunDB space to track and display download counts.
+ * No authentication required - anyone can read/increment counts.
+ */
+
+(function() {
+  'use strict';
+
+  // Default public GunDB peers
+  const DEFAULT_PEERS = [
+    'https://gun.defucc.me/gun',
+    'https://gun.o8.is/gun',
+    'https://shogun-relay.scobrudot.dev/gun',
+    'https://relay.peer.ooo/gun',
+  ];
+
+  /**
+   * TunecampDownloadStats class
+   * Tracks download counts via GunDB
+   */
+  class TunecampDownloadStats {
+    /**
+     * Initialize the download stats system
+     * @param {Object} options - Configuration options
+     * @param {Array} options.peers - GunDB peer URLs (default: public peers)
+     * @param {string} options.namespace - GunDB namespace (default: 'tunecamp-stats')
+     */
+    constructor(options = {}) {
+      this.peers = options.peers || DEFAULT_PEERS;
+      this.root = options.root || 'shogun';
+      this.namespace = options.namespace || 'tunecamp-stats';
+      this.gun = null;
+      this.initialized = false;
+      
+      // Initialize GunDB when script loads
+      this.init();
+    }
+
+    /**
+     * Initialize GunDB connection
+     */
+    async init() {
+      // Check if Gun is available
+      if (typeof Gun === 'undefined') {
+        console.warn('GunDB not loaded. Download stats disabled.');
+        return;
+      }
+
+      // Initialize Gun with peers
+      this.gun = Gun({
+        peers: this.peers,
+        localStorage: true,
+      });
+
+      this.initialized = true;
+      console.log('📊 Tunecamp Download Stats initialized');
+    }
+
+    /**
+     * Wait for Gun to be ready
+     */
+    async waitForInit() {
+      if (this.initialized) return;
+      
+      return new Promise((resolve, reject) => {
+        let attempts = 0;
+        const maxAttempts = 50; // 5 seconds max
+        
+        const check = () => {
+          if (this.initialized) {
+            resolve();
+          } else if (attempts >= maxAttempts) {
+            reject(new Error('GunDB initialization timeout'));
+          } else {
+            attempts++;
+            setTimeout(check, 100);
+          }
+        };
+        check();
+      });
+    }
+
+    /**
+     * Get download count for a release
+     * @param {string} releaseSlug - The release identifier
+     * @returns {Promise<number>} Download count
+     */
+    async getDownloadCount(releaseSlug) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('downloads')
+          .once((data) => {
+            resolve(data ? parseInt(data, 10) || 0 : 0);
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(0), 3000);
+      });
+    }
+
+    /**
+     * Get download count for a specific track
+     * @param {string} releaseSlug - The release identifier
+     * @param {string} trackId - The track identifier (filename or index)
+     * @returns {Promise<number>} Download count
+     */
+    async getTrackDownloadCount(releaseSlug, trackId) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('tracks')
+          .get(trackId)
+          .get('downloads')
+          .once((data) => {
+            resolve(data ? parseInt(data, 10) || 0 : 0);
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(0), 3000);
+      });
+    }
+
+    /**
+     * Increment download count for a release
+     * @param {string} releaseSlug - The release identifier
+     * @returns {Promise<number>} New download count
+     */
+    async incrementDownloadCount(releaseSlug) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      const currentCount = await this.getDownloadCount(releaseSlug);
+      const newCount = currentCount + 1;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('downloads')
+          .put(newCount, (ack) => {
+            if (ack.err) {
+              console.error('Error incrementing download count:', ack.err);
+              resolve(currentCount);
+            } else {
+              resolve(newCount);
+            }
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(newCount), 2000);
+      });
+    }
+
+    /**
+     * Increment download count for a specific track
+     * @param {string} releaseSlug - The release identifier
+     * @param {string} trackId - The track identifier
+     * @returns {Promise<number>} New download count
+     */
+    async incrementTrackDownloadCount(releaseSlug, trackId) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      const currentCount = await this.getTrackDownloadCount(releaseSlug, trackId);
+      const newCount = currentCount + 1;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('tracks')
+          .get(trackId)
+          .get('downloads')
+          .put(newCount, (ack) => {
+            if (ack.err) {
+              console.error('Error incrementing track download count:', ack.err);
+              resolve(currentCount);
+            } else {
+              resolve(newCount);
+            }
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(newCount), 2000);
+      });
+    }
+
+    /**
+     * Subscribe to download count changes (real-time updates)
+     * @param {string} releaseSlug - The release identifier
+     * @param {function} callback - Called with new count on each update
+     */
+    subscribeToDownloadCount(releaseSlug, callback) {
+      if (!this.gun) {
+        callback(0);
+        return () => {};
+      }
+
+      const ref = this.gun
+        .get(this.root).get(this.namespace)
+        .get('releases')
+        .get(releaseSlug)
+        .get('downloads');
+
+      ref.on((data) => {
+        callback(data ? parseInt(data, 10) || 0 : 0);
+      });
+
+      // Return unsubscribe function
+      return () => ref.off();
+    }
+
+    /**
+     * Format download count for display
+     * @param {number} count - Download count
+     * @returns {string} Formatted string (e.g., "1.2K", "3.5M")
+     */
+    formatCount(count) {
+      if (count < 1000) return count.toString();
+      if (count < 1000000) return (count / 1000).toFixed(1).replace(/\.0$/, '') + 'K';
+      return (count / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
+    }
+  }
+
+  // Expose globally
+  window.TunecampDownloadStats = TunecampDownloadStats;
+})();

package/templates/retro/assets/player.js

@@ -0,0 +1,219 @@
+// Tunecamp Audio Player
+
+class AudioPlayer {
+  constructor() {
+    this.audio = new Audio();
+    this.currentTrack = 0;
+    this.isPlaying = false;
+    this.tracks = window.tracks || [];
+    
+    this.initElements();
+    this.attachListeners();
+    this.loadTrack(0);
+  }
+  
+  initElements() {
+    this.playBtn = document.getElementById('playBtn');
+    this.prevBtn = document.getElementById('prevBtn');
+    this.nextBtn = document.getElementById('nextBtn');
+    this.progressBar = document.getElementById('progressBar');
+    this.volumeBar = document.getElementById('volumeBar');
+    this.currentTimeEl = document.getElementById('currentTime');
+    this.durationEl = document.getElementById('duration');
+    this.playerTitle = document.getElementById('playerTitle');
+    this.playerArtist = document.getElementById('playerArtist');
+  }
+  
+  attachListeners() {
+    // Play/Pause
+    if (this.playBtn) {
+      this.playBtn.addEventListener('click', () => this.togglePlay());
+    }
+    
+    // Previous track
+    if (this.prevBtn) {
+      this.prevBtn.addEventListener('click', () => this.previousTrack());
+    }
+    
+    // Next track
+    if (this.nextBtn) {
+      this.nextBtn.addEventListener('click', () => this.nextTrack());
+    }
+    
+    // Progress bar
+    if (this.progressBar) {
+      this.progressBar.addEventListener('input', (e) => {
+        const time = (this.audio.duration / 100) * e.target.value;
+        this.audio.currentTime = time;
+      });
+    }
+    
+    // Volume
+    if (this.volumeBar) {
+      this.volumeBar.addEventListener('input', (e) => {
+        this.audio.volume = e.target.value / 100;
+      });
+      this.audio.volume = this.volumeBar.value / 100;
+    }
+    
+    // Audio events
+    this.audio.addEventListener('timeupdate', () => this.updateProgress());
+    this.audio.addEventListener('loadedmetadata', () => this.updateDuration());
+    this.audio.addEventListener('ended', () => this.nextTrack());
+    
+    // Track click listeners
+    document.querySelectorAll('.track-item').forEach((item, index) => {
+      item.addEventListener('click', (e) => {
+        if (!e.target.closest('.track-download-btn')) {
+          this.playTrack(index);
+        }
+      });
+    });
+  }
+  
+  loadTrack(index) {
+    if (!this.tracks[index]) return;
+    
+    this.currentTrack = index;
+    const track = this.tracks[index];
+    
+    this.audio.src = track.url;
+    
+    if (this.playerTitle) {
+      this.playerTitle.textContent = track.title;
+    }
+    
+    if (this.playerArtist && track.artist) {
+      this.playerArtist.textContent = track.artist;
+    }
+    
+    // Update active track in list
+    document.querySelectorAll('.track-item').forEach((item, i) => {
+      if (i === index) {
+        item.classList.add('playing');
+      } else {
+        item.classList.remove('playing');
+      }
+    });
+  }
+  
+  togglePlay() {
+    if (this.isPlaying) {
+      this.pause();
+    } else {
+      this.play();
+    }
+  }
+  
+  play() {
+    this.audio.play();
+    this.isPlaying = true;
+    
+    if (this.playBtn) {
+      this.playBtn.innerHTML = '<i class="fas fa-pause"></i>';
+    }
+  }
+  
+  pause() {
+    this.audio.pause();
+    this.isPlaying = false;
+    
+    if (this.playBtn) {
+      this.playBtn.innerHTML = '<i class="fas fa-play"></i>';
+    }
+  }
+  
+  playTrack(index) {
+    this.loadTrack(index);
+    this.play();
+  }
+  
+  previousTrack() {
+    let prev = this.currentTrack - 1;
+    if (prev < 0) {
+      prev = this.tracks.length - 1;
+    }
+    this.playTrack(prev);
+  }
+  
+  nextTrack() {
+    let next = this.currentTrack + 1;
+    if (next >= this.tracks.length) {
+      next = 0;
+    }
+    this.playTrack(next);
+  }
+  
+  updateProgress() {
+    if (!this.audio.duration) return;
+    
+    const percent = (this.audio.currentTime / this.audio.duration) * 100;
+    
+    if (this.progressBar) {
+      this.progressBar.value = percent;
+    }
+    
+    if (this.currentTimeEl) {
+      this.currentTimeEl.textContent = this.formatTime(this.audio.currentTime);
+    }
+  }
+  
+  updateDuration() {
+    if (this.durationEl) {
+      this.durationEl.textContent = this.formatTime(this.audio.duration);
+    }
+  }
+  
+  formatTime(seconds) {
+    if (!seconds || isNaN(seconds)) return '0:00';
+    
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, '0')}`;
+  }
+}
+
+// Initialize player when DOM is ready
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', () => {
+    if (window.tracks && window.tracks.length > 0) {
+      window.player = new AudioPlayer();
+    }
+  });
+} else {
+  if (window.tracks && window.tracks.length > 0) {
+    window.player = new AudioPlayer();
+  }
+}
+
+// Global function for track buttons
+function playTrack(index) {
+  if (window.player) {
+    window.player.playTrack(index);
+  }
+}
+
+// Download all function
+function downloadAll() {
+  // Call tracking hook if registered (for download stats)
+  if (typeof window.onDownloadAll === 'function') {
+    try {
+      window.onDownloadAll();
+    } catch (e) {
+      console.warn('Download tracking error:', e);
+    }
+  }
+  
+  // Perform the actual downloads
+  if (window.tracks) {
+    window.tracks.forEach(track => {
+      const a = document.createElement('a');
+      a.href = track.url;
+      a.download = track.title;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+    });
+  }
+}
+