@lmna22/aio-downloader 2.0.2 → 2.0.3

package/README.md

@@ -1,6 +1,6 @@
 # @lmna22/aio-downloader
 
-> All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, X/Twitter, Lahelu, and Xiaohongshu/RedNote.
+> All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, X (Twitter), Lahelu, Xiaohongshu (RedNote), and more.
 
 [![npm version](https://img.shields.io/npm/v/@lmna22/aio-downloader.svg)](https://www.npmjs.com/package/@lmna22/aio-downloader)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -22,6 +22,8 @@ Scrape and download videos, audio, and images from multiple platforms with a sin
 | **X / Twitter** | ✅ (Best quality) | — | ✅ | — |
 | **Lahelu** | ✅ | — | ✅ | — |
 | **Xiaohongshu/RedNote** | ✅ | — | ✅ | — |
+| **Dailymotion** | ✅ | ✅ | ✅ | ✅ |
+| **Spotify** | — | ✅ (MP3, Opus, WAV) | — | — |
 
 - 🔗 **Auto-detect platform** from URL — just pass any supported link
 - 📦 **Programmatic API** — designed for Node.js applications, bots, and scripts
@@ -110,14 +112,63 @@ if (result.status) {
     console.log(result.data.stats.collects);
     console.log(result.data.stats.comments);
     console.log(result.data.media.url);
-    
+
     // Download the media
     const { download } = require("@lmna22/aio-downloader");
     await download(result.data.media.url, `./downloads/${result.data.fileName}`);
 }
 ```
 
-*(See the API Reference below for other platforms: Pinterest, Pixiv, Twitter, Lahelu)*
+### Dailymotion
+
+```javascript
+const { lmna } = require("@lmna22/aio-downloader");
+
+// Download video
+const result = await lmna.dailymotion("https://www.dailymotion.com/video/x8z3v2y");
+
+if (result.status) {
+    console.log(result.data.title);
+    console.log(result.data.author);
+    console.log(result.data.views);
+    console.log(result.data.url);
+}
+
+// Search videos
+const searchResult = await lmna.dailymotion("https://www.dailymotion.com/search/programming", { query: "programming", limit: 10 });
+
+if (searchResult.status) {
+    console.log(searchResult.data.videos);
+}
+```
+
+### Spotify
+
+```javascript
+const { lmna } = require("@lmna22/aio-downloader");
+
+// Get track metadata (returns search query, does not download)
+const result = await lmna.spotify("https://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT");
+
+if (result.status) {
+    console.log(result.data.title);
+    console.log(result.data.artist);
+    console.log(result.data.cover);
+    console.log(result.data.searchQuery); // Use this to download with yt-dlp
+    
+    // Download using yt-dlp or similar tool
+    // Example: yt-dlp "ytsearch1:Never Gonna Give You Up audio" --extract-audio --audio-format mp3
+}
+
+// Supported formats: mp3, opus, wav
+const mp3Result = await lmna.spotify("https://open.spotify.com/track/abc123", { format: 'mp3' });
+const opusResult = await lmna.spotify("https://open.spotify.com/track/abc123", { format: 'opus' });
+const wavResult = await lmna.spotify("https://open.spotify.com/track/abc123", { format: 'wav' });
+```
+
+**Note:** Spotify scraper returns metadata and a search query. Use yt-dlp or similar tool to download the actual audio file using the provided searchQuery.
+
+*(See the API Reference below for other platforms: Pinterest, Pixiv, Twitter, Lahelu, Dailymotion)*
 
 ---
 
@@ -157,6 +208,9 @@ await aioDownloader("https://lahelu.com/post/abc123");
 await aioDownloader("https://www.xiaohongshu.com/explore/abc123");
 await aioDownloader("https://www.rednote.com/explore/abc123");
 await aioDownloader("https://xhslink.com/abc123");
+await aioDownloader("https://www.dailymotion.com/video/x8z3v2y");
+await aioDownloader("https://www.dailymotion.com/search/programming");
+await aioDownloader("https://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT");
 
 // Force a specific platform
 await aioDownloader("https://example.com/video", { platform: "youtube", quality: 5 });
@@ -173,6 +227,9 @@ detectPlatform("https://lahelu.com/post/abc");       // "lahelu"
 detectPlatform("https://xiaohongshu.com/explore/abc"); // "xiaohongshu"
 detectPlatform("https://rednote.com/explore/abc");   // "xiaohongshu"
 detectPlatform("https://xhslink.com/abc");           // "xiaohongshu"
+detectPlatform("https://dailymotion.com/video/x8z3v2y"); // "dailymotion"
+detectPlatform("https://dailymotion.com/search/music"); // "dailymotion"
+detectPlatform("https://open.spotify.com/track/abc123"); // "spotify"
 detectPlatform("https://unknown.com");               // null
 ```
 
@@ -196,6 +253,8 @@ await lmna.pixiv(url, options);
 await lmna.twitter(url);
 await lmna.lahelu(url);
 await lmna.xiaohongshu(url);
+await lmna.dailymotion(url, options);
+await lmna.spotify(url, options);
 
 // All return: { status, platform, data?, message? }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lmna22/aio-downloader",
-    "version": "2.0.2",
+    "version": "2.0.3",
     "description": "All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, and X/Twitter. Scrape and download videos, audio, and images from multiple platforms with a single library.",
     "main": "src/index.js",
     "scripts": {
@@ -20,7 +20,10 @@
         "image",
         "media",
         "scraper",
-        "aio"
+        "aio",
+        "lahelu",
+        "dailymotion",
+        "xiaohongshu"
     ],
     "author": "",
     "license": "MIT",
@@ -37,7 +40,7 @@
         "axios-cookiejar-support": "^5.0.0",
         "cheerio": "^1.0.0",
         "ffmpeg-static": "^5.0.0",
-        "puppeteer": "^24.0.0",
+        "puppeteer": "^24.40.0",
         "qs": "^6.13.0",
         "tough-cookie": "^5.1.0",
         "youtube-dl-exec": "^3.1.4"

package/src/index.js

@@ -6,6 +6,8 @@ const pixivDownloader = require("./lib/pixiv");
 const twitterDownloader = require("./lib/twitter");
 const laheluDownloader = require("./lib/lahelu");
 const xiaohongshuDownloader = require("./lib/xiaohongshu");
+const dailymotionDownloader = require("./lib/dailymotion");
+const spotifyDownloader = require("./lib/spotify");
 const download = require("./download");
 
 const PLATFORM_PATTERNS = [
@@ -17,6 +19,8 @@ const PLATFORM_PATTERNS = [
     { name: "twitter", test: (url) => /(?:twitter\.com\/|x\.com\/)/i.test(url) },
     { name: "lahelu", test: (url) => /lahelu\.com\/post\//i.test(url) },
     { name: "xiaohongshu", test: (url) => /xiaohongshu\.com|rednote\.com|xhslink\.com/i.test(url) },
+    { name: "dailymotion", test: (url) => /dailymotion\.com\//i.test(url) },
+    { name: "spotify", test: (url) => /open\.spotify\.com\//i.test(url) },
 ];
 
 function detectPlatform(url) {
@@ -35,6 +39,8 @@ const scrapers = {
     twitter: (url) => twitterDownloader(url),
     lahelu: (url) => laheluDownloader(url),
     xiaohongshu: (url) => xiaohongshuDownloader(url),
+    dailymotion: (url, options) => dailymotionDownloader(url, options),
+    spotify: (url, options) => spotifyDownloader(url, options),
 };
 
 async function aioDownloader(url, options = {}) {
@@ -42,7 +48,7 @@ async function aioDownloader(url, options = {}) {
 
     if (!platform) {
         throw new Error(
-            `Unsupported or unrecognized URL: ${url}. Supported platforms: YouTube, Instagram, TikTok, Pinterest, Pixiv, X/Twitter.`
+            `Unsupported or unrecognized URL: ${url}. Supported platforms: YouTube, Instagram, TikTok, Pinterest, Pixiv, X/Twitter, Dailymotion, Spotify.`
         );
     }
 
@@ -64,6 +70,8 @@ const lmna = {
     twitter: (url) => twitterDownloader(url),
     lahelu: (url) => laheluDownloader(url),
     xiaohongshu: (url) => xiaohongshuDownloader(url),
+    dailymotion: (url, options) => dailymotionDownloader(url, options),
+    spotify: (url, options) => spotifyDownloader(url, options),
 };
 
 module.exports = {

package/src/lib/dailymotion.js

@@ -0,0 +1,278 @@
+const puppeteer = require('puppeteer');
+
+function extractVideoId(url) {
+    const patterns = [
+        /dailymotion\.com\/video\/([a-zA-Z0-9]+)/,
+        /dai\.ly\/([a-zA-Z0-9]+)/,
+        /dailymotion\.com\/embed\/video\/([a-zA-Z0-9]+)/,
+    ];
+
+    for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match) return match[1];
+    }
+    return null;
+}
+
+async function fetchDailymotionData(url) {
+    const videoId = extractVideoId(url);
+    if (!videoId) {
+        throw new Error('Invalid Dailymotion URL');
+    }
+
+    let browser;
+    try {
+        browser = await puppeteer.launch({
+            headless: 'new',
+            args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-gpu']
+        });
+
+        const page = await browser.newPage();
+        await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
+
+        let videoData = null;
+        let masterM3U8Url = null;
+        let masterM3U8Content = null;
+
+        page.on('response', async (response) => {
+            const resUrl = response.url();
+
+            if (resUrl.includes('geo.dailymotion.com') && resUrl.includes('/video/') && resUrl.includes('.json') && !resUrl.includes('fields=')) {
+                try {
+                    const data = await response.json();
+                    if (data && data.id === videoId) {
+                        videoData = data;
+                    }
+                } catch (e) { }
+            }
+
+            if (resUrl.includes('cdndirector.dailymotion.com') && resUrl.includes('.m3u8') && !resUrl.includes('cookie_sync') && !resUrl.includes('af=')) {
+                try {
+                    const text = await response.text();
+                    if (text.includes('#EXTM3U') && text.includes('#EXT-X-STREAM-INF')) {
+                        masterM3U8Url = resUrl;
+                        masterM3U8Content = text;
+                    }
+                } catch (e) { }
+            }
+
+            if (resUrl.includes('graphql-eu-west-1.api.dailymotion.com') && resUrl.includes('video')) {
+                try {
+                    const data = await response.json();
+                    if (data && data.data && data.data.video && data.data.video.xid === videoId) {
+                        const v = data.data.video;
+                        videoData = {
+                            id: v.xid || v.id,
+                            title: v.title,
+                            description: v.description,
+                            duration: v.duration,
+                            author: v.author,
+                            thumbnails: {
+                                '360': v.thumbnailx360,
+                                '480': v.thumbnailx480,
+                                '720': v.thumbnailx720
+                            },
+                            created_time: v.createdAt ? Math.floor(new Date(v.createdAt).getTime() / 1000) : null,
+                            views_total: v.views,
+                            likes_total: v.likes
+                        };
+                    }
+                } catch (e) { }
+            }
+        });
+
+        await page.goto(url, {
+            waitUntil: 'networkidle0',
+            timeout: 30000
+        });
+
+        await new Promise(r => setTimeout(r, 5000));
+
+        if (!videoData) {
+            videoData = await page.evaluate((id) => {
+                const content = document.documentElement.outerHTML;
+
+                const jsonPattern = new RegExp('{"id":"[^"]*' + id + '[^}]*"title":"[^"]+"[^}]*}', 'g');
+                const matches = content.match(jsonPattern);
+
+                if (matches && matches.length > 0) {
+                    for (const match of matches) {
+                        try {
+                            const data = JSON.parse(match);
+                            if (data.id === id && data.title) {
+                                return {
+                                    id: data.id,
+                                    title: data.title,
+                                    description: data.description || '',
+                                    duration: data.duration || 0,
+                                    author: data.author || '',
+                                    thumbnails: data.thumbnails || {},
+                                    created_time: data.created_time,
+                                    views_total: data.views_total,
+                                    likes_total: data.likes_total
+                                };
+                            }
+                        } catch (e) { }
+                    }
+                }
+                return null;
+            }, videoId);
+        }
+
+        if (!videoData) {
+            throw new Error('Failed to fetch video metadata');
+        }
+
+        if (!masterM3U8Content || !masterM3U8Content.includes('#EXT-X-STREAM-INF')) {
+            throw new Error('No video stream found');
+        }
+
+        await browser.close();
+
+        const lines = masterM3U8Content.split('\n');
+        const streams = [];
+        let currentBandwidth = 0;
+        let currentResolution = '';
+        let currentName = '';
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith('#EXT-X-STREAM-INF:')) {
+                const bwMatch = line.match(/BANDWIDTH=(\d+)/);
+                const resMatch = line.match(/RESOLUTION=(\d+x\d+)/);
+                const nameMatch = line.match(/NAME="([^"]+)"/);
+
+                currentBandwidth = bwMatch ? parseInt(bwMatch[1]) : 0;
+                currentResolution = resMatch ? resMatch[1] : '';
+                currentName = nameMatch ? nameMatch[1] : '';
+            } else if (line && !line.startsWith('#') && (line.includes('.m3u8') || line.includes('dmcdn'))) {
+                if (currentResolution) {
+                    const [width, height] = currentResolution.split('x').map(Number);
+                    const fullUrl = line.startsWith('http') ? line : masterM3U8Url.substring(0, masterM3U8Url.lastIndexOf('/') + 1) + line;
+                    streams.push({
+                        quality: currentName ? `${currentName}p` : `${height}p`,
+                        height: height,
+                        width: width,
+                        bandwidth: currentBandwidth,
+                        name: currentName,
+                        fps: null,
+                        formatId: currentResolution,
+                        type: 'MP4',
+                        url: fullUrl,
+                    });
+                }
+                currentResolution = '';
+            }
+        }
+
+        if (streams.length === 0) {
+            throw new Error('No video qualities found in manifest');
+        }
+
+        streams.sort((a, b) => a.height - b.height);
+
+        streams.push({
+            quality: 'Audio Only',
+            height: 0,
+            width: 0,
+            bandwidth: streams[0].bandwidth,
+            name: 'Audio',
+            fps: null,
+            formatId: 'audio',
+            type: 'MP3',
+            url: streams[0].url,
+        });
+
+        const metadata = {
+            id: videoData.id || videoId,
+            title: videoData.title || 'Unknown',
+            description: videoData.description || '',
+            duration: videoData.duration || 0,
+            views: parseInt(videoData.views_total) || 0,
+            likes: parseInt(videoData.likes_total) || 0,
+            owner: {
+                screenname: videoData.owner?.screenname || videoData.author || '',
+                username: videoData.owner?.username || '',
+                id: videoData.owner?.id || '',
+            },
+            thumbnail: videoData.thumbnails?.['720'] || videoData.thumbnails?.['480'] || videoData.thumbnails?.['360'] || '',
+            uploadDate: videoData.created_time ? new Date(videoData.created_time * 1000).toISOString() : '',
+        };
+
+        return {
+            metadata,
+            streams,
+            info: videoData,
+        };
+    } catch (err) {
+        if (browser) await browser.close().catch(() => { });
+        throw err;
+    }
+}
+
+async function dailymotionDownloader(url) {
+    if (typeof url !== 'string' || (!url.includes('dailymotion.com') && !url.includes('dai.ly'))) {
+        return {
+            status: false,
+            platform: "dailymotion",
+            message: 'Invalid Dailymotion URL'
+        };
+    }
+
+    try {
+        const data = await fetchDailymotionData(url);
+
+        if (!data || !data.metadata || !data.streams || data.streams.length === 0) {
+            return {
+                status: false,
+                platform: "dailymotion",
+                message: 'Failed to get video data'
+            };
+        }
+
+        const { metadata, streams } = data;
+
+        const videoUrls = streams
+            .filter(s => s.quality !== 'Audio Only')
+            .map(s => s.url);
+
+        const audioUrl = streams.find(s => s.quality === 'Audio Only')?.url;
+
+        const qualities = streams
+            .filter(s => s.quality !== 'Audio Only')
+            .map(s => ({
+                quality: s.quality,
+                resolution: `${s.width}x${s.height}`,
+                bandwidth: s.bandwidth,
+                url: s.url
+            }));
+
+        return {
+            status: true,
+            platform: "dailymotion",
+            data: {
+                id: metadata.id,
+                title: metadata.title,
+                description: metadata.description,
+                duration: metadata.duration,
+                views: metadata.views,
+                likes: metadata.likes,
+                author: metadata.owner?.screenname || metadata.owner?.username,
+                thumbnail: metadata.thumbnail,
+                uploadDate: metadata.uploadDate,
+                url: videoUrls.length > 0 ? videoUrls : [audioUrl],
+                audio: audioUrl || null,
+                qualities: qualities,
+                isVideo: true
+            }
+        };
+    } catch (error) {
+        return {
+            status: false,
+            platform: "dailymotion",
+            message: error.message
+        };
+    }
+}
+
+module.exports = dailymotionDownloader;

package/src/lib/spotify.js

@@ -0,0 +1,89 @@
+const axios = require('axios');
+const youtubedl = require('youtube-dl-exec');
+
+async function getSpotifyTrackInfo(url) {
+    try {
+        const trackId = url.split('track/')[1]?.split('?')[0] || url.split('track/')[1]?.split('/')[0];
+
+        if (!trackId) {
+            throw new Error('Invalid Spotify track URL');
+        }
+
+        const { data } = await axios.get(`https://open.spotify.com/oembed?url=${encodeURIComponent(url)}`, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+            }
+        });
+
+        let title = data.title || 'Unknown Title';
+        let cover = data.thumbnail_url || '';
+
+        const searchQuery = title;
+
+        return {
+            id: trackId,
+            title: title.replace(/\s*-\s*(Original Audio|Spotify|Audio|Official Video|Lyrics)$/i, '').trim(),
+            artist: 'Spotify Track',
+            cover: cover,
+            url: url,
+            searchQuery: searchQuery
+        };
+    } catch (e) {
+        throw new Error('Failed to fetch Spotify metadata: ' + e.message);
+    }
+}
+
+async function spotifyDownloader(url, options = {}) {
+    const { format = 'mp3' } = options;
+
+    if (typeof url !== 'string' || !url.includes('spotify.com/')) {
+        return {
+            status: false,
+            platform: 'spotify',
+            message: 'Invalid Spotify URL. Only track links are supported.'
+        };
+    }
+
+    try {
+        const trackMetadata = await getSpotifyTrackInfo(url);
+
+        // search on youtube for the track
+        let videoUrl = null;
+        try {
+            const searchResult = await youtubedl(`ytsearch1:${trackMetadata.searchQuery}`, {
+                dumpSingleJson: true,
+                noCheckCertificates: true,
+                noWarnings: true,
+            });
+            videoUrl = searchResult.entries?.[0]?.webpage_url || null;
+        } catch (err) {
+            console.error('Spotify YouTube Search Error:', err.message);
+        }
+
+        return {
+            status: true,
+            platform: 'spotify',
+            data: {
+                id: trackMetadata.id,
+                title: trackMetadata.title,
+                artist: trackMetadata.artist,
+                cover: trackMetadata.cover,
+                url: trackMetadata.url,
+                videoUrl: videoUrl, // This will be used by test.js to auto-download
+                searchQuery: trackMetadata.searchQuery,
+                format: format,
+                isAudio: true,
+                message: videoUrl ? 'Successfully found a matching video on YouTube' : 'Could not find a matching video on YouTube'
+            }
+        };
+
+    } catch (err) {
+        return {
+            status: false,
+            platform: 'spotify',
+            message: err.message
+        };
+    }
+}
+
+module.exports = spotifyDownloader;