gerdur-core 0.0.0-probe → 1.0.0

package/dist/converter/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.youtube = exports.spotify = exports.tidal = void 0;
+__exportStar(require("./parse"), exports);
+__exportStar(require("./deezer"), exports);
+exports.tidal = __importStar(require("./tidal"));
+exports.spotify = __importStar(require("./spotify"));
+exports.youtube = __importStar(require("./youtube"));

package/dist/converter/parse.d.ts

@@ -0,0 +1,18 @@
+import type { albumType, artistInfoType, playlistInfo, trackType } from '../types';
+type linkType = 'track' | 'album' | 'artist' | 'playlist';
+export type urlPartsType = {
+    id: string;
+    type: 'track' | 'album' | 'audiobook' | 'artist' | 'playlist' | 'spotify-track' | 'spotify-album' | 'spotify-playlist' | 'spotify-artist' | 'tidal-track' | 'tidal-album' | 'tidal-playlist' | 'tidal-artist' | 'youtube-track';
+};
+export declare const getUrlParts: (url: string, setToken?: boolean) => Promise<urlPartsType>;
+/**
+ * Deezer, Spotify or Tidal links only
+ * @param {String} url
+ */
+export declare const parseInfo: (url: string) => Promise<{
+    info: urlPartsType;
+    linktype: linkType;
+    linkinfo: Record<string, any> | artistInfoType | albumType | playlistInfo;
+    tracks: trackType[];
+}>;
+export {};

package/dist/converter/parse.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInfo = exports.getUrlParts = void 0;
+const __1 = require("../");
+const spotify_uri_1 = __importDefault(require("spotify-uri"));
+const spotify = __importStar(require("./spotify"));
+const tidal = __importStar(require("./tidal"));
+const youtube = __importStar(require("./youtube"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const http_1 = require("../lib/http");
+const queue = new p_queue_1.default({ concurrency: 10 });
+const getUrlParts = async (url, setToken = false) => {
+    if (url.startsWith('spotify:')) {
+        const spotify = url.split(':');
+        url = 'https://open.spotify.com/' + spotify[1] + '/' + spotify[2];
+    }
+    const site = url.match(/deezer|spotify|tidal|youtu\.?be/);
+    if (!site) {
+        throw new Error('Unknown URL: ' + url);
+    }
+    switch (site[0]) {
+        case 'deezer':
+            if (url.includes('page.link')) {
+                const { request } = await (0, http_1.headRequest)(url);
+                url = request.res.responseUrl;
+            }
+            const deezerUrlParts = url.split(/\/(\w+)\/(\d+)/);
+            return { type: deezerUrlParts[1], id: deezerUrlParts[2] };
+        case 'spotify':
+            const spotifyUrlParts = spotify_uri_1.default.parse(url);
+            if (setToken) {
+                await spotify.setSpotifyAnonymousToken();
+            }
+            return { type: ('spotify-' + spotifyUrlParts.type), id: spotifyUrlParts.id };
+        case 'tidal':
+            const tidalUrlParts = url.split(/\/(\w+)\/(\d+|\w+-\w+-\w+-\w+-\w+)/);
+            return { type: ('tidal-' + tidalUrlParts[1]), id: tidalUrlParts[2] };
+        case 'youtube':
+            let yotubeId = url.split('v=')[1];
+            if (yotubeId.includes('&')) {
+                yotubeId = yotubeId.split('&')[0];
+            }
+            return { type: 'youtube-track', id: yotubeId };
+        case 'youtu.be':
+            return { type: 'youtube-track', id: url.split('/').pop() };
+        default:
+            throw new Error('Unable to parse URL: ' + url);
+    }
+};
+exports.getUrlParts = getUrlParts;
+/**
+ * Deezer, Spotify or Tidal links only
+ * @param {String} url
+ */
+const parseInfo = async (url) => {
+    const info = await (0, exports.getUrlParts)(url, true);
+    if (!info.id) {
+        throw new Error('Unable to parse id');
+    }
+    let linktype = 'track';
+    let linkinfo = {};
+    let tracks = [];
+    switch (info.type) {
+        case 'track': {
+            tracks.push(await (0, __1.getTrackInfo)(info.id));
+            break;
+        }
+        case 'album':
+        case 'audiobook':
+            linkinfo = await (0, __1.getAlbumInfo)(info.id);
+            linktype = 'album';
+            const albumTracks = await (0, __1.getAlbumTracks)(info.id);
+            tracks = albumTracks.data;
+            break;
+        case 'playlist':
+            linkinfo = await (0, __1.getPlaylistInfo)(info.id);
+            linktype = 'playlist';
+            const playlistTracks = await (0, __1.getPlaylistTracks)(info.id);
+            tracks = playlistTracks.data;
+            break;
+        case 'artist':
+            linkinfo = await (0, __1.getArtistInfo)(info.id);
+            linktype = 'artist';
+            const artistAlbums = await (0, __1.getDiscography)(info.id);
+            await queue.addAll(artistAlbums.data.map((album) => {
+                return async () => {
+                    if (album.ARTISTS.find((a) => a.ART_ID === info.id)) {
+                        const albumTracks = await (0, __1.getAlbumTracks)(album.ALB_ID);
+                        tracks = [...tracks, ...albumTracks.data.filter((t) => t.ART_ID === info.id)];
+                    }
+                };
+            }));
+            break;
+        case 'spotify-track':
+            tracks.push(await spotify.track2deezer(info.id));
+            break;
+        case 'spotify-album':
+            const [spotifyAlbumInfo, spotifyTracks] = await spotify.album2deezer(info.id);
+            tracks = spotifyTracks;
+            linkinfo = spotifyAlbumInfo;
+            linktype = 'album';
+            break;
+        case 'spotify-playlist':
+            const [spotifyPlaylistInfo, spotifyPlaylistTracks] = await spotify.playlist2Deezer(info.id);
+            tracks = spotifyPlaylistTracks;
+            linkinfo = spotifyPlaylistInfo;
+            linktype = 'playlist';
+            break;
+        case 'spotify-artist':
+            tracks = await spotify.artist2Deezer(info.id);
+            linktype = 'artist';
+            break;
+        case 'tidal-track':
+            tracks.push(await tidal.track2deezer(info.id));
+            break;
+        case 'tidal-album':
+            const [tidalAlbumInfo, tidalAlbumTracks] = await tidal.album2deezer(info.id);
+            tracks = tidalAlbumTracks;
+            linkinfo = tidalAlbumInfo;
+            linktype = 'album';
+            break;
+        case 'tidal-playlist':
+            const [tidalPlaylistInfo, tidalPlaylistTracks] = await tidal.playlist2Deezer(info.id);
+            tracks = tidalPlaylistTracks;
+            linkinfo = tidalPlaylistInfo;
+            linktype = 'playlist';
+            break;
+        case 'tidal-artist':
+            tracks = await tidal.artist2Deezer(info.id);
+            linktype = 'artist';
+            break;
+        case 'youtube-track':
+            tracks.push(await youtube.track2deezer(info.id));
+            break;
+        default:
+            throw new Error('Unknown type: ' + info.type);
+    }
+    return {
+        info,
+        linktype,
+        linkinfo,
+        tracks: tracks.map((t) => {
+            if (t.VERSION && !t.SNG_TITLE.includes(t.VERSION)) {
+                t.SNG_TITLE += ' ' + t.VERSION;
+            }
+            return t;
+        }),
+    };
+};
+exports.parseInfo = parseInfo;

package/dist/converter/spotify.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="spotify-api" />
+import SpotifyWebApi from 'spotify-web-api-node';
+import type { playlistInfo, trackType } from '../types';
+type tokensType = {
+    clientId: string;
+    accessToken: string;
+    accessTokenExpirationTimestampMs: number;
+    isAnonymous: true;
+};
+/**
+ * Export core spotify module
+ */
+export declare const spotifyApi: SpotifyWebApi;
+/**
+ * Set spotify tokens anonymously. This is required to bypass api limits.
+ * @returns {tokensType}
+ */
+export declare const setSpotifyAnonymousToken: () => Promise<tokensType>;
+/**
+ * Convert spotify songs to deezer
+ * @param {String} id Spotify track id
+ * @returns {trackType}
+ */
+export declare const track2deezer: (id: string) => Promise<trackType>;
+/**
+ * Convert spotify albums to deezer
+ * @param {String} id Spotify track id
+ */
+export declare const album2deezer: (id: string) => Promise<[import("../types").albumType, trackType[]]>;
+/**
+ * Convert playlist to deezer
+ * @param {String} id Spotify track id
+ */
+export declare const playlist2Deezer: (id: string, onError?: ((item: SpotifyApi.PlaylistTrackObject, index: number, err: Error) => void) | undefined) => Promise<[playlistInfo, trackType[]]>;
+/**
+ * Convert artist songs to deezer. Maxium of 10 tracks.
+ * @param {String} id Spotify track id
+ */
+export declare const artist2Deezer: (id: string, onError?: ((item: SpotifyApi.TrackObjectFull, index: number, err: Error) => void) | undefined) => Promise<trackType[]>;
+export {};

package/dist/converter/spotify.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.artist2Deezer = exports.playlist2Deezer = exports.album2deezer = exports.track2deezer = exports.setSpotifyAnonymousToken = exports.spotifyApi = void 0;
+const spotify_web_api_node_1 = __importDefault(require("spotify-web-api-node"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const deezer_1 = require("./deezer");
+const http_1 = require("../lib/http");
+let anonymousToken = null;
+let anonymousTokenPromise = null;
+const hasValidAnonymousToken = () => Boolean(anonymousToken && anonymousToken.accessTokenExpirationTimestampMs - 60000 > Date.now());
+/**
+ * Parse offset number
+ * @param {String} next next page url
+ * @returns {Number}
+ */
+const getOffset = (next) => {
+    if (next) {
+        const o = next.split('&').find((p) => p.includes('offset='));
+        return o ? Number(o.split('=')[1]) : 0;
+    }
+    return 0;
+};
+/**
+ * Limit process concurrency
+ */
+const queue = new p_queue_1.default({ concurrency: 25 });
+/**
+ * Export core spotify module
+ */
+exports.spotifyApi = new spotify_web_api_node_1.default();
+/**
+ * Set spotify tokens anonymously. This is required to bypass api limits.
+ * @returns {tokensType}
+ */
+const setSpotifyAnonymousToken = async () => {
+    if (hasValidAnonymousToken() && anonymousToken) {
+        exports.spotifyApi.setAccessToken(anonymousToken.accessToken);
+        return anonymousToken;
+    }
+    if (!anonymousTokenPromise) {
+        anonymousTokenPromise = (0, http_1.getJson)('https://open.spotify.com/get_access_token?reason=transport&productType=embed')
+            .then((data) => {
+            anonymousToken = data;
+            exports.spotifyApi.setAccessToken(data.accessToken);
+            return data;
+        })
+            .finally(() => {
+            anonymousTokenPromise = null;
+        });
+    }
+    return await anonymousTokenPromise;
+};
+exports.setSpotifyAnonymousToken = setSpotifyAnonymousToken;
+/**
+ * Convert spotify songs to deezer
+ * @param {String} id Spotify track id
+ * @returns {trackType}
+ */
+const track2deezer = async (id) => {
+    const { body } = await exports.spotifyApi.getTrack(id);
+    return await (0, deezer_1.isrc2deezer)(body.name, body.external_ids.isrc);
+};
+exports.track2deezer = track2deezer;
+/**
+ * Convert spotify albums to deezer
+ * @param {String} id Spotify track id
+ */
+const album2deezer = async (id) => {
+    const { body } = await exports.spotifyApi.getAlbum(id);
+    return await (0, deezer_1.upc2deezer)(body.name, body.external_ids.upc);
+};
+exports.album2deezer = album2deezer;
+/**
+ * Convert playlist to deezer
+ * @param {String} id Spotify track id
+ */
+const playlist2Deezer = async (id, onError) => {
+    const { body } = await exports.spotifyApi.getPlaylist(id);
+    const tracks = [];
+    let items = body.tracks.items;
+    let offset = getOffset(body.tracks.next);
+    while (offset !== 0) {
+        const { body } = await exports.spotifyApi.getPlaylistTracks(id, { limit: 100, offset: offset ? offset : 0 });
+        offset = getOffset(body.next);
+        items = [...items, ...body.items];
+    }
+    await queue.addAll(items.map((item, index) => {
+        return async () => {
+            try {
+                if (item.track) {
+                    const track = await (0, deezer_1.isrc2deezer)(item.track.name, item.track.external_ids.isrc);
+                    track.TRACK_POSITION = index + 1;
+                    tracks.push(track);
+                }
+            }
+            catch (err) {
+                if (onError) {
+                    onError(item, index, err);
+                }
+            }
+        };
+    }));
+    const dateCreated = new Date().toISOString();
+    const playlistInfoData = {
+        PLAYLIST_ID: body.id,
+        PARENT_USERNAME: body.owner.id,
+        PARENT_USER_ID: body.owner.id,
+        PICTURE_TYPE: 'cover',
+        PLAYLIST_PICTURE: body.images[0].url,
+        TITLE: body.name,
+        TYPE: '0',
+        STATUS: '0',
+        USER_ID: body.owner.id,
+        DATE_ADD: dateCreated,
+        DATE_MOD: dateCreated,
+        DATE_CREATE: dateCreated,
+        NB_SONG: body.tracks.total,
+        NB_FAN: 0,
+        CHECKSUM: body.id,
+        HAS_ARTIST_LINKED: false,
+        IS_SPONSORED: false,
+        IS_EDITO: false,
+        __TYPE__: 'playlist',
+    };
+    return [playlistInfoData, tracks];
+};
+exports.playlist2Deezer = playlist2Deezer;
+/**
+ * Convert artist songs to deezer. Maxium of 10 tracks.
+ * @param {String} id Spotify track id
+ */
+const artist2Deezer = async (id, onError) => {
+    // Artist tracks are limited to 10 items
+    const { body } = await exports.spotifyApi.getArtistTopTracks(id, 'GB');
+    const tracks = [];
+    await queue.addAll(body.tracks.map((item, index) => {
+        return async () => {
+            try {
+                const track = await (0, deezer_1.isrc2deezer)(item.name, item.external_ids.isrc);
+                tracks.push(track);
+            }
+            catch (err) {
+                if (onError) {
+                    onError(item, index, err);
+                }
+            }
+        };
+    }));
+    return tracks;
+};
+exports.artist2Deezer = artist2Deezer;

package/dist/converter/tidal.d.ts

@@ -0,0 +1,146 @@
+import type { playlistInfo, trackType } from '../types';
+interface commonType {
+    id: number;
+    title: string;
+    duration: number;
+    premiumStreamingOnly: boolean;
+    trackNumber: number;
+    copyright: string;
+    url: string;
+    explicit: boolean;
+    audioQuality: string;
+    artist: {
+        id: number;
+        name: string;
+        type: string;
+    };
+    album: {
+        id: number;
+        title: string;
+        cover: string;
+    };
+}
+interface tidalTrackType extends commonType {
+    isrc: string;
+    editable: boolean;
+    audioQuality: string;
+    album: {
+        id: number;
+        title: string;
+        cover: string;
+    };
+}
+interface tidalAlbumType extends commonType {
+    cover: string;
+    videoCover: null | string;
+    upc: string;
+    audioQuality: string;
+}
+interface tidalPlaylistType {
+    uuid: string;
+    title: string;
+    numberOfTracks: number;
+    numberOfVideos: number;
+    creator: {
+        id: number;
+    };
+    description: string;
+    duration: number;
+    lastUpdated: string;
+    created: string;
+    type: string;
+    publicPlaylist: boolean;
+    url: string;
+    image: string;
+}
+interface listType {
+    limit: number;
+    offset: number;
+    totalNumberOfItems: number;
+}
+interface tidalArtistTopTracksType extends listType {
+    items: tidalTrackType[];
+}
+interface tidalAlbumsTracksType extends listType {
+    items: tidalAlbumType[];
+}
+interface tidalPlaylistTracksType extends listType {
+    items: tidalTrackType[];
+}
+/**
+ * Get a track by its id
+ * @param string} id - track id
+ * @example tidal.getTrack('64975224')
+ */
+export declare const getTrack: (id: string) => Promise<tidalTrackType>;
+/**
+ * Convert a tidal track to deezer
+ * @param {string} id - track id
+ */
+export declare const track2deezer: (id: string) => Promise<trackType>;
+/**
+ * Get an album by its id
+ * @param {string} id - album id
+ * @example tidal.getAlbum('80216363')
+ */
+export declare const getAlbum: (id: string) => Promise<tidalAlbumType>;
+/**
+ * Convert a tidal albums to deezer
+ * @param {string} id - album id
+ */
+export declare const album2deezer: (id: string) => Promise<[import("../types").albumType, trackType[]]>;
+/**
+ * Get album tracks by album id
+ * @param {string} id - album id
+ * @example tidal.getAlbumTracks('80216363')
+ */
+export declare const getAlbumTracks: (id: string) => Promise<tidalAlbumsTracksType>;
+/**
+ * Get artist albums by artist id
+ * @param {string} id - artist id
+ * @example tidal.getArtistAlbums('3575680')
+ */
+export declare const getArtistAlbums: (id: string) => Promise<tidalAlbumsTracksType>;
+/**
+ * Get top tracks by artist
+ * @param {string} id - artist id
+ * @example tidal.getArtistTopTracks('3575680')
+ */
+export declare const getArtistTopTracks: (id: string) => Promise<tidalArtistTopTracksType>;
+/**
+ * Get a playlist by its uuid
+ * @param {string} uuid - playlist uuid
+ * @example tidal.getPlaylist('1c5d01ed-4f05-40c4-bd28-0f73099e9648')
+ */
+export declare const getPlaylist: (uuid: string) => Promise<tidalPlaylistType>;
+/**
+ * Get playlist tracks by playlist uuid
+ * @param {string} uuid - playlist uuid
+ * @example tidal.getPlaylistTracks('1c5d01ed-4f05-40c4-bd28-0f73099e9648')
+ */
+export declare const getPlaylistTracks: (uuid: string) => Promise<tidalPlaylistTracksType>;
+/**
+ * Get valid urls to album art
+ * @param {string} uuid - album art uuid (can be found as cover property in album object)
+ * @example tidal.albumArtToUrl('9a56f482-e9cf-46c3-bb21-82710e7854d4')
+ * @returns {Object}
+ */
+export declare const albumArtToUrl: (uuid: string) => {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
+/**
+ * Find tidal artists tracks on deezer
+ * @param {string} id - artist id
+ * @example tidal.artist2Deezer('3575680')
+ */
+export declare const artist2Deezer: (id: string, onError?: ((item: tidalTrackType, index: number, err: Error) => void) | undefined) => Promise<trackType[]>;
+/**
+ * Find same set of playlist tracks on deezer
+ * @param {string} uuid - playlist uuid
+ * @example tidal.playlist2Deezer('1c5d01ed-4f05-40c4-bd28-0f73099e9648')
+ */
+export declare const playlist2Deezer: (uuid: string, onError?: ((item: tidalTrackType, index: number, err: Error) => void) | undefined) => Promise<[playlistInfo, trackType[]]>;
+export {};