discord-player-deezer 2.0.0-beta.2 → 2.0.0-beta.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +25 -3
- package/dist/index.js +54 -10
- package/package.json +2 -3
- package/readme.md +23 -45
package/dist/index.d.ts
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { Track, ExtractorStreamable, BaseExtractor, ExtractorSearchContext, Playlist as Playlist$1, ExtractorInfo } from 'discord-player';
|
|
1
|
+
import { Track, ExtractorStreamable, BaseExtractor, ExtractorSearchContext, Playlist as Playlist$1, ExtractorInfo, Player } from 'discord-player';
|
|
2
2
|
import { Playlist, Track as Track$1 } from '@mithron/deezer-music-metadata';
|
|
3
3
|
import * as crypto from 'crypto';
|
|
4
4
|
import { PassThrough } from 'stream';
|
|
@@ -28,11 +28,33 @@ declare class DeezerExtractor extends BaseExtractor<DeezerExtractorOptions> {
|
|
|
28
28
|
validate(query: string): Promise<boolean>;
|
|
29
29
|
buildPlaylistData(data: Playlist, handleContext: ExtractorSearchContext): Playlist$1;
|
|
30
30
|
handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo>;
|
|
31
|
-
buildTrack(track: Track$1,
|
|
31
|
+
buildTrack(track: Track$1, { requestedBy }: ExtractorSearchContext): Track<unknown>;
|
|
32
|
+
bridge(track: Track): Promise<ExtractorStreamable | null>;
|
|
32
33
|
stream(info: Track): Promise<ExtractorStreamable>;
|
|
33
34
|
}
|
|
34
35
|
|
|
35
36
|
declare function getCrypto(): Promise<typeof crypto>;
|
|
37
|
+
type ArrayOrObject<T> = T | T[];
|
|
38
|
+
interface DeezerSearchTrackResponse {
|
|
39
|
+
data: {
|
|
40
|
+
link: string;
|
|
41
|
+
title: string;
|
|
42
|
+
album: {
|
|
43
|
+
cover_xl?: string;
|
|
44
|
+
cover_medium?: string;
|
|
45
|
+
cover_small?: string;
|
|
46
|
+
cover?: string;
|
|
47
|
+
};
|
|
48
|
+
artist: {
|
|
49
|
+
name: string;
|
|
50
|
+
};
|
|
51
|
+
duration: number;
|
|
52
|
+
type: "track";
|
|
53
|
+
}[];
|
|
54
|
+
}
|
|
55
|
+
declare function buildTrackFromSearch(track: DeezerSearchTrackResponse, player: Player, requestedBy?: Track['requestedBy']): Track<unknown>[];
|
|
56
|
+
declare function extractTrackId(query: string): string;
|
|
57
|
+
declare function searchOneTrack(query: string): Promise<DeezerSearchTrackResponse | undefined>;
|
|
36
58
|
declare function streamTrack(track: Track, ext: DeezerExtractor): Promise<PassThrough>;
|
|
37
59
|
declare const deezerRegex: {
|
|
38
60
|
readonly track: RegExp;
|
|
@@ -41,4 +63,4 @@ declare const deezerRegex: {
|
|
|
41
63
|
};
|
|
42
64
|
declare function validate(query: string): boolean;
|
|
43
65
|
|
|
44
|
-
export { DeezerExtractor, type DeezerExtractorOptions, type DeezerUserInfo, deezerRegex, getCrypto, streamTrack, validate };
|
|
66
|
+
export { type ArrayOrObject, DeezerExtractor, type DeezerExtractorOptions, type DeezerSearchTrackResponse, type DeezerUserInfo, buildTrackFromSearch, deezerRegex, extractTrackId, getCrypto, searchOneTrack, streamTrack, validate };
|
package/dist/index.js
CHANGED
|
@@ -31,18 +31,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
|
|
|
31
31
|
var src_exports = {};
|
|
32
32
|
__export(src_exports, {
|
|
33
33
|
DeezerExtractor: () => DeezerExtractor,
|
|
34
|
+
buildTrackFromSearch: () => buildTrackFromSearch,
|
|
34
35
|
deezerRegex: () => deezerRegex,
|
|
36
|
+
extractTrackId: () => extractTrackId,
|
|
35
37
|
getCrypto: () => getCrypto,
|
|
38
|
+
searchOneTrack: () => searchOneTrack,
|
|
36
39
|
streamTrack: () => streamTrack,
|
|
37
40
|
validate: () => validate
|
|
38
41
|
});
|
|
39
42
|
module.exports = __toCommonJS(src_exports);
|
|
40
43
|
|
|
41
44
|
// src/DeezerExtractor.ts
|
|
42
|
-
var
|
|
45
|
+
var import_discord_player2 = require("discord-player");
|
|
43
46
|
var import_deezer_music_metadata = require("@mithron/deezer-music-metadata");
|
|
44
47
|
|
|
45
48
|
// src/utils/util.ts
|
|
49
|
+
var import_discord_player = require("discord-player");
|
|
46
50
|
var import_stream = require("stream");
|
|
47
51
|
var IV = Buffer.from(Array.from({ length: 8 }, (_, x) => x));
|
|
48
52
|
var rawCrypto;
|
|
@@ -53,13 +57,43 @@ async function getCrypto() {
|
|
|
53
57
|
}
|
|
54
58
|
return rawCrypto;
|
|
55
59
|
}
|
|
60
|
+
var DeezerAPIRoutes = {
|
|
61
|
+
searchTrack(query, limit) {
|
|
62
|
+
const url = `https://api.deezer.com/search/track?q=${encodeURIComponent(query)}&${limit ? `limit=${limit}` : ""}`;
|
|
63
|
+
return url;
|
|
64
|
+
}
|
|
65
|
+
};
|
|
66
|
+
function buildTrackFromSearch(track, player, requestedBy) {
|
|
67
|
+
return track.data.map((v) => new import_discord_player.Track(player, {
|
|
68
|
+
source: "arbitrary",
|
|
69
|
+
duration: import_discord_player.Util.buildTimeCode(import_discord_player.Util.parseMS(v.duration * 1e3)),
|
|
70
|
+
author: Array.isArray(v.artist) ? v.artist.map((a) => a.name).join(", ") : v.artist.name,
|
|
71
|
+
url: v.link,
|
|
72
|
+
title: v.title,
|
|
73
|
+
thumbnail: v.album.cover_xl || v.album.cover_medium || v.album.cover || v.album.cover_small || "https://play-lh.googleusercontent.com/xtIOV8iPeAY4GrldTDo3CbLAEpbea2DqnfxaB4Nn2p5qz6KAiumY74qH86pgu1HA1A",
|
|
74
|
+
live: false,
|
|
75
|
+
requestedBy
|
|
76
|
+
}));
|
|
77
|
+
}
|
|
78
|
+
function extractTrackId(query) {
|
|
79
|
+
if (!validate(query)) throw new Error("Invalid track url");
|
|
80
|
+
const trackIdWithUrlParams = query.split("/").at(-1);
|
|
81
|
+
if (!trackIdWithUrlParams) throw new Error("Cannot find track ID");
|
|
82
|
+
return trackIdWithUrlParams.split("?")[0];
|
|
83
|
+
}
|
|
84
|
+
async function searchOneTrack(query) {
|
|
85
|
+
const url = DeezerAPIRoutes.searchTrack(query, 1);
|
|
86
|
+
const trackRes = await fetch(url);
|
|
87
|
+
if (trackRes.status !== 200) throw new Error("Fetch failed");
|
|
88
|
+
const trackData = await trackRes.json();
|
|
89
|
+
const track = trackData;
|
|
90
|
+
return track;
|
|
91
|
+
}
|
|
56
92
|
async function streamTrack(track, ext) {
|
|
57
|
-
const trackIdWithUrlParams = track.url.split("/").at(-1);
|
|
58
|
-
if (!trackIdWithUrlParams || !validate(track.url)) throw new Error("INVALID TRACK");
|
|
59
93
|
const decryptionKey = ext.options.decryptionKey;
|
|
60
94
|
if (!decryptionKey) throw new Error("MISSING DEEZER DECRYPTION KEY");
|
|
61
95
|
const crypto = await getCrypto();
|
|
62
|
-
const trackId =
|
|
96
|
+
const trackId = extractTrackId(track.url);
|
|
63
97
|
const trackHash = crypto.createHash("md5").update(trackId, "ascii").digest("hex");
|
|
64
98
|
const trackKey = Buffer.alloc(16);
|
|
65
99
|
for (let iter = 0; iter < 16; iter++)
|
|
@@ -153,7 +187,7 @@ function validate(query) {
|
|
|
153
187
|
}
|
|
154
188
|
|
|
155
189
|
// src/DeezerExtractor.ts
|
|
156
|
-
var DeezerExtractor = class extends
|
|
190
|
+
var DeezerExtractor = class extends import_discord_player2.BaseExtractor {
|
|
157
191
|
async activate() {
|
|
158
192
|
if (!this.options.decryptionKey) process.emitWarning("Decryption Key missing! This is needed for extracting streams.");
|
|
159
193
|
else {
|
|
@@ -178,7 +212,7 @@ var DeezerExtractor = class extends import_discord_player.BaseExtractor {
|
|
|
178
212
|
buildPlaylistData(data, handleContext) {
|
|
179
213
|
const raw = data.url.split("/");
|
|
180
214
|
const identifier = raw[raw.length - 1].split("?")[0];
|
|
181
|
-
return new
|
|
215
|
+
return new import_discord_player2.Playlist(this.context.player, {
|
|
182
216
|
title: data.name,
|
|
183
217
|
thumbnail: data.thumbnail[0].url,
|
|
184
218
|
author: {
|
|
@@ -202,17 +236,24 @@ var DeezerExtractor = class extends import_discord_player.BaseExtractor {
|
|
|
202
236
|
}
|
|
203
237
|
throw new Error("Unable to get data from Deezer");
|
|
204
238
|
}
|
|
205
|
-
buildTrack(track,
|
|
206
|
-
return new
|
|
239
|
+
buildTrack(track, { requestedBy }) {
|
|
240
|
+
return new import_discord_player2.Track(this.context.player, {
|
|
207
241
|
title: track.name,
|
|
208
242
|
author: track.author.map((v) => v.name).join(", "),
|
|
209
243
|
url: track.url,
|
|
210
244
|
source: "arbitrary",
|
|
211
245
|
thumbnail: track.thumbnail[0].url,
|
|
212
|
-
duration:
|
|
213
|
-
requestedBy
|
|
246
|
+
duration: import_discord_player2.Util.buildTimeCode(import_discord_player2.Util.parseMS(track.duration)),
|
|
247
|
+
requestedBy
|
|
214
248
|
});
|
|
215
249
|
}
|
|
250
|
+
async bridge(track) {
|
|
251
|
+
const deezerTrack = await searchOneTrack(`${track.author} ${track.source === "youtube" ? track.cleanTitle : track.title}`);
|
|
252
|
+
if (!deezerTrack || !deezerTrack?.data[0]) return null;
|
|
253
|
+
const dpTrack = buildTrackFromSearch(deezerTrack, this.context.player, track.requestedBy);
|
|
254
|
+
const stream = this.stream(dpTrack[0]);
|
|
255
|
+
return stream;
|
|
256
|
+
}
|
|
216
257
|
stream(info) {
|
|
217
258
|
return streamTrack(info, this);
|
|
218
259
|
}
|
|
@@ -221,8 +262,11 @@ DeezerExtractor.identifier = "com.retrouser955.discord-player.deezr-ext";
|
|
|
221
262
|
// Annotate the CommonJS export names for ESM import in node:
|
|
222
263
|
0 && (module.exports = {
|
|
223
264
|
DeezerExtractor,
|
|
265
|
+
buildTrackFromSearch,
|
|
224
266
|
deezerRegex,
|
|
267
|
+
extractTrackId,
|
|
225
268
|
getCrypto,
|
|
269
|
+
searchOneTrack,
|
|
226
270
|
streamTrack,
|
|
227
271
|
validate
|
|
228
272
|
});
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "discord-player-deezer",
|
|
3
|
-
"version": "2.0.0-beta.
|
|
3
|
+
"version": "2.0.0-beta.3",
|
|
4
4
|
"description": "A custom extractor made for discord-player that enables you to extract from Deezer.",
|
|
5
5
|
"main": "dist/index.js",
|
|
6
6
|
"author": "retro_ig",
|
|
@@ -11,7 +11,6 @@
|
|
|
11
11
|
},
|
|
12
12
|
"devDependencies": {
|
|
13
13
|
"@discord-player/extractor": "^4.5.1",
|
|
14
|
-
"cross-env": "^7.0.3",
|
|
15
14
|
"discord-player": "^6.7.1",
|
|
16
15
|
"prettier": "^3.4.2",
|
|
17
16
|
"tslint": "^6.1.3",
|
|
@@ -22,7 +21,7 @@
|
|
|
22
21
|
"scripts": {
|
|
23
22
|
"build": "yarn lint && tsup",
|
|
24
23
|
"lint": "tslint -p tsconfig.json",
|
|
25
|
-
"npm:publish": "
|
|
24
|
+
"npm:publish": "yarn build && npm publish --access public"
|
|
26
25
|
},
|
|
27
26
|
"repository": {
|
|
28
27
|
"type": "git",
|
package/readme.md
CHANGED
|
@@ -1,65 +1,43 @@
|
|
|
1
|
-
# Discord Player Deezer
|
|
1
|
+
# Discord Player Deezer
|
|
2
2
|
|
|
3
|
-
Discord Player Deezer
|
|
3
|
+
Discord Player Deezer is a Deezer platform plugin for discord-player
|
|
4
4
|
|
|
5
|
-
|
|
5
|
+
# Installation
|
|
6
6
|
|
|
7
7
|
```bash
|
|
8
|
-
npm install discord-player-deezer
|
|
9
|
-
# or
|
|
10
|
-
yarn add discord-player-deezer
|
|
8
|
+
$ npm install discord-player-deezer
|
|
11
9
|
```
|
|
12
10
|
|
|
13
|
-
|
|
11
|
+
# Register the extractor
|
|
14
12
|
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
const player = getMainPlayerSomehow()
|
|
13
|
+
```ts
|
|
14
|
+
import { DeezerExtractor } from "discord-player-deezer"
|
|
15
|
+
import { Player } from "discord-player"
|
|
19
16
|
|
|
20
|
-
player
|
|
21
|
-
```
|
|
17
|
+
const player = new Player(...)
|
|
22
18
|
|
|
23
|
-
|
|
24
|
-
```
|
|
25
|
-
import { default as DeezerExtractor } from "discord-player-deezer"
|
|
19
|
+
await player.extractors.register(DeezerExtractor, {})
|
|
20
|
+
```
|
|
26
21
|
|
|
27
|
-
|
|
22
|
+
# Extracting Streams
|
|
28
23
|
|
|
29
|
-
|
|
30
|
-
```
|
|
24
|
+
As Deezer sends DMCA to repositories containing the hard-coded decryption key, it is not provided. You can find this key in the code of related projects (deezer downloaders) and your client-side JavaScript code.
|
|
31
25
|
|
|
32
|
-
### Typescript
|
|
33
26
|
```ts
|
|
34
|
-
import DeezerExtractor from "discord-player-deezer"
|
|
27
|
+
import { DeezerExtractor } from "discord-player-deezer"
|
|
28
|
+
import { Player } from "discord-player"
|
|
35
29
|
|
|
36
|
-
const player =
|
|
30
|
+
const player = new Player(...)
|
|
37
31
|
|
|
38
|
-
player.extractors.register(DeezerExtractor
|
|
32
|
+
await player.extractors.register(DeezerExtractor, {
|
|
33
|
+
decryptionKey: "master-decryption-key"
|
|
34
|
+
})
|
|
39
35
|
```
|
|
40
36
|
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
That's it! See the magic happen as you bot is now able to play from Deezer URLs
|
|
37
|
+
# Important information
|
|
44
38
|
|
|
45
|
-
|
|
39
|
+
As Node has migrated from openssl for decryption, we must use the `--openssl-legacy-provider` flag when starting our application with stream extraction
|
|
46
40
|
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
interface DeezerOptions {
|
|
50
|
-
forceEngine?: EngineType;
|
|
51
|
-
createStream?: () => Promise<string|Readable>;
|
|
52
|
-
beforeCreateStream?: () => Promise<unknown>|unknown;
|
|
53
|
-
}
|
|
54
|
-
```
|
|
55
|
-
One thing to keep in mind is, while using the two functions, if you want to access track data, you must you `useTrack()` function exported by the library. For example ...
|
|
56
|
-
|
|
57
|
-
```ts
|
|
58
|
-
player.extractors.register(DeezerExtractor, {
|
|
59
|
-
createStream: () => {
|
|
60
|
-
const track = useTrack()
|
|
61
|
-
|
|
62
|
-
return getStreamSomehow(track)
|
|
63
|
-
}
|
|
64
|
-
})
|
|
41
|
+
```bash
|
|
42
|
+
$ node --openssl-legacy-provider yourfile.js
|
|
65
43
|
```
|