aqualink 2.1.3 → 2.3.0

package/README.md

@@ -22,50 +22,44 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
   - https://github.com/topi314/LavaLyrics (RECOMMENDED)
   - https://github.com/DRSchlaubi/lyrics.kt (?)
   - https://github.com/DuncteBot/java-timed-lyrics (RECOMMENDED)
-  
-# Tralalero Tralala 2.1.0 Released
+
+
+# Tralalero Tralala 2.3.0 Released
 ---
+
+- now is ~21% more lightweight, reduced disk space
+
 - Improved the `AQUA` module
-  - Faster nodes loading
-  - Faster plugin loading
-  - Better listeners for player
-  - Faster resolving system for playlists
-
-- Remade the `Connection` system
-  - Less overheard now.
-  - Faster connections
-  - Improved the checkings
-  - Improved error handling
-  - Fixed creating useless Objects and arrays
-
-- Fully rewrite the `Node` system
-  - Way faster connections
-  - More stable (i think so)
-  - Faster events / messages / payloads handling
-  - Better stats handling (reusing, creating, destroyin)
-  - Some more bug fixes and stuff i forgot.
+  - 3x better cleanup system
+  - Fixed some memory leaks
+  - Improved long process support
+  - Faster node caching
 
 - Remade the `Player` module
-  - Now support Lazy Loading by default
-  - Better State Updates
-  - Improved Garbage Collection
-  - Rewrite to use direct comparasions
+  - Added circular buffer for previousTracks (way more memory efficient)
+  - Reorganized the event handlings
+  - Way better Memory management
 
-- Improved the `Rest` module
-  - Lazy loading of http2
-  - Faster request chunks
-  - Some overall upgrades
+- Rewrite the `Node` system
+  - Fixed an memory leak in connections
+  - Improved the overal speed
+  - Improved code readbility / modules
+  - improved cleanup System
+  - Better long runtime
+  - Rewrite the Filter system
 
-- Improved `Track` module
-  - Faster track looking
-  - More micro optimizations (use Boolean instead of !!)
+- Improved `Rest` code
+  - Fixed lyrics (both search and get)
+  - Better chunks system for more performance
 
-- Remade the INDEX.D.TS File: Added more 1000 lines of code. Added autocomplete, options, and documented everything.
+- Improved `fetchImage` speed and recourses
 
 # Docs (Wiki)
-- https://github.com/ToddyTheNoobDud/AquaLink/wiki
+- https://toddythenoobdud.github.io/aqualink.github.io/
+
+- Example bot: https://github.com/ToddyTheNoobDud/Kenium-Music
 
-- Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
+- Discord support: https://discord.com/invite/K4CVv84VBC
 
 
 # How to install
@@ -147,7 +141,9 @@ client.on("messageCreate", async (message) => {
 
     if (resolve.loadType === 'playlist') {
         await message.channel.send(`Added ${resolve.tracks.length} songs from ${resolve.playlistInfo.name} playlist.`);
-        player.queue.add(resolve.tracks);
+        for (const track of result.tracks) {
+          player.queue.add(track);
+        }
         if (!player.playing && !player.paused) return player.play();
 
     } else if (resolve.loadType === 'search' || resolve.loadType === 'track') {

package/build/handlers/autoplay.js

@@ -3,15 +3,30 @@ const https = require('https');
 function fetch(url, options = {}) {
     return new Promise((resolve, reject) => {
         const req = https.get(url, options, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetch(res.headers.location, options).then(resolve).catch(reject);
+            }
+            
             if (res.statusCode !== 200) {
+                res.resume();
                 reject(new Error(`Request failed. Status code: ${res.statusCode}`));
                 return;
             }
-            let data = '';
-            res.on('data', (chunk) => data += chunk);
-            res.on('end', () => resolve(data));
+            
+            const chunks = [];
+            res.on('data', chunk => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString()));
+        });
+        
+        req.setTimeout(10000, () => {
+            req.destroy();
+            reject(new Error('Request timeout'));
+        });
+        
+        req.on('error', err => {
+            reject(err);
         });
-        req.on('error', reject);
+        
         req.end();
     });
 }
@@ -20,15 +35,23 @@ async function scAutoPlay(url) {
     try {
         const html = await fetch(`${url}/recommended`);
         
-        const matches = [...html.matchAll(/<a itemprop="url" href="(\/.*?)"/g)];
+        const regex = /<a itemprop="url" href="(\/.*?)"/g;
+        const hrefs = new Set();
+        let match;
         
-        const hrefs = [...new Set(matches.map(match => `https://soundcloud.com${match[1]}`))];
+        while ((match = regex.exec(html)) !== null) {
+            hrefs.add(`https://soundcloud.com${match[1]}`);
+        }
         
-        if (hrefs.length === 0) {
+        if (hrefs.size === 0) {
             throw new Error("No recommended tracks found on SoundCloud.");
         }
         
-        const shuffledHrefs = hrefs.sort(() => Math.random() - 0.5);
+        const shuffledHrefs = Array.from(hrefs);
+        for (let i = shuffledHrefs.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffledHrefs[i], shuffledHrefs[j]] = [shuffledHrefs[j], shuffledHrefs[i]];
+        }
         
         return shuffledHrefs;
     } catch (error) {
@@ -40,21 +63,28 @@ async function scAutoPlay(url) {
 async function spAutoPlay(track_id) {
     try {
         const tokenResponse = await fetch("https://open.spotify.com/get_access_token?reason=transport&productType=embed");
-        const { accessToken } = JSON.parse(tokenResponse);
+        const tokenData = JSON.parse(tokenResponse);
+        const accessToken = tokenData?.accessToken;
         
         if (!accessToken) throw new Error("Failed to retrieve Spotify access token");
         
-        const recommendationsResponse = await fetch(`https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${track_id}`, {
-            headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' }
-        });
+        const recommendationsResponse = await fetch(
+            `https://api.spotify.com/v1/recommendations?limit=5&seed_tracks=${track_id}&fields=tracks.id`, 
+            {
+                headers: { 
+                    Authorization: `Bearer ${accessToken}`, 
+                    'Content-Type': 'application/json'
+                }
+            }
+        );
         
-        const { tracks } = JSON.parse(recommendationsResponse);
+        const data = JSON.parse(recommendationsResponse);
+        const tracks = data?.tracks || [];
         
-        if (!tracks || tracks.length === 0) {
+        if (tracks.length === 0) {
             throw new Error("No recommended tracks found on Spotify.");
         }
         
-        // Return a random track ID
         return tracks[Math.floor(Math.random() * tracks.length)].id;
     } catch (error) {
         console.error("Error fetching Spotify recommendations:", error);

package/build/handlers/fetchImage.js

@@ -1,10 +1,11 @@
-const http2 = require('http2');
+const https = require('https');
 const sourceHandlers = new Map([
     ['spotify', uri => fetchThumbnail(`https://open.spotify.com/oembed?url=${uri}`)],
     ['youtube', identifier => fetchYouTubeThumbnail(identifier)]
 ]);
 const YOUTUBE_URL_TEMPLATE = (quality) => (id) => `https://img.youtube.com/vi/${id}/${quality}.jpg`;
 const YOUTUBE_QUALITIES = ['maxresdefault', 'hqdefault', 'mqdefault', 'default'].map(YOUTUBE_URL_TEMPLATE);
+
 async function getImageUrl(info) {
     if (!info?.sourceName || !info?.uri) return null;
     const handler = sourceHandlers.get(info.sourceName.toLowerCase());
@@ -16,42 +17,34 @@ async function getImageUrl(info) {
         return null;
     }
 }
+
 function fetchThumbnail(url) {
     return new Promise((resolve, reject) => {
-        const client = http2.connect(url);
-        
-        const req = client.request({ ':path': '/' });
-        
-        let data = '';
-        
-        req.on('response', (headers, flags) => {
-            if (headers[':status'] !== 200) {
-                return reject(`Failed to fetch: ${headers[':status']}`);
+        https.get(url, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                return reject(`Failed to fetch: ${res.statusCode}`);
             }
-        });
-        req.on('data', chunk => {
-            data += chunk;
-        });
-        req.on('end', () => {
-            try {
-                const json = JSON.parse(data);
-                resolve(json.thumbnail_url || null);
-            } catch (error) {
-                reject(`JSON parse error: ${error.message}`);
-            } finally {
-                client.close();
-            }
-        });
-        req.on('error', (error) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.thumbnail_url || null);
+                } catch (error) {
+                    reject(`JSON parse error: ${error.message}`);
+                }
+            });
+        }).on('error', (error) => {
             reject(`Request error: ${error.message}`);
-            client.close();
         });
-        req.end();
     });
 }
+
 async function fetchYouTubeThumbnail(identifier) {
     const promises = YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)));
-    const results = await Promise.race(promises);
-    return results || null;
+    const firstResult = await Promise.race(promises);
+    return firstResult || null;
 }
-module.exports = { getImageUrl };
+
+module.exports = { getImageUrl };