discord-player 7.0.0-dev.0 → 7.0.0-dev.2

package/README.md

@@ -86,28 +86,6 @@ $ npm install --save ffmpeg-binaries
 
 > Use `FFMPEG_PATH` environment variable to load ffmpeg from custom path.
 
-#### Streaming Library
-
-**The following method is deprecated and will be removed in the future. Please switch to [discord-player-youtubei](https://npmjs.com/discord-player-youtubei).**
-
-**Not recommended**:
-
-YouTube streaming is not supported without installing one of the following package. If you want to add support for YouTube playback, you need to install a streaming library. This step is not needed if you do not plan on using youtube source.
-
-```bash
-$ npm install --save youtube-ext
-# or
-$ npm install --save play-dl
-# or
-$ npm install --save @distube/ytdl-core
-# or
-$ npm install --save yt-stream
-# or
-$ npm install --save ytdl-core
-```
-
-Once you have completed these installations, let's proceed with writing a simple music bot.
-
 ### Setup
 
 Let's create a main player instance. This instance handles and keeps track of all the queues and its components.
@@ -147,13 +125,31 @@ const { Player, createErisCompat } = require('discord-player');
 const player = new Player(createErisCompat(client));
 ```
 
+Before you add the command, make sure to provide the context to the commands if you wish to use discord-player's hooks (like `useMainPlayer`).
+
+### Before
+
+```js index.js
+// execute the command
+await command.execute(interaction);
+```
+
+### After
+
+```js index.js
+// execute the command
+await player.context.provide({ guild: interaction.guild }, () => command.execute(interaction));
+```
+
+This allows discord-player to automatically know the current guild and the queue, resulting in cleaner code and seamless integration. This eradicates the need to pass the player instance to the command or use hacks like `client.player = player`.
+
 Let's move on to the command part. You can define the command as per your requirements. We will only focus on the command part:
 
 ```js play.js
 const { useMainPlayer } = require('discord-player');
 
 export async function execute(interaction) {
-    const player = useMainPlayer();
+    const player = useMainPlayer(); // get player instance
     const channel = interaction.member.voice.channel;
     if (!channel) return interaction.reply('You are not connected to a voice channel!'); // make sure we have a voice channel
     const query = interaction.options.getString('query', true); // we need input/query to play

package/dist/index.d.ts

@@ -12,10 +12,8 @@ import { BridgeProvider } from '@discord-player/extractor';
 import { RequestOptions } from 'http';
 import { StreamType, AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus } from 'discord-voip';
 export { AudioPlayer, CreateAudioPlayerOptions, JoinConfig, JoinVoiceChannelOptions, createAudioPlayer, getVoiceConnection, getVoiceConnections, joinVoiceChannel } from 'discord-voip';
-import * as _discord_player_ffmpeg from '@discord-player/ffmpeg';
-import { FFmpeg } from '@discord-player/ffmpeg';
+import { FFmpegLib } from '@discord-player/ffmpeg';
 export * from '@discord-player/ffmpeg';
-import { downloadOptions } from 'ytdl-core';
 
 declare function isErisProxy(client: any): client is Eris.Client;
 /**
@@ -514,7 +512,7 @@ declare function FFMPEG_ARGS_PIPED(fmt?: string): string[];
  * @param stream The source stream
  * @param options FFmpeg stream options
  */
-declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable | Duplex | FFmpeg;
+declare function createFFmpegStream(stream: Readable | Duplex | string, options?: FFmpegStreamOptions): Readable | Duplex;
 
 type Filters = keyof typeof AudioFilters.filters;
 type EQPreset = {
@@ -567,7 +565,7 @@ declare class FFmpegFilterer<Meta = unknown> {
      * @param source The stream source
      * @param options The stream options
      */
-    createStream(source: string | Readable, options: FFmpegStreamOptions): Readable | stream.Duplex | _discord_player_ffmpeg.FFmpeg;
+    createStream(source: string | Readable, options: FFmpegStreamOptions): Readable | stream.Duplex;
     /**
      * Set ffmpeg filters
      * @param filters The filters
@@ -1809,27 +1807,19 @@ declare function useContext<T = unsafe>(context: Context<T>): T | undefined;
  * @param node guild queue node resolvable
  */
 declare function useHistory<Meta = unknown>(): GuildQueueHistory<Meta> | null;
-declare function useHistory<Meta = unknown>(node: NodeResolvable): GuildQueueHistory<Meta> | null;
 
 /**
  * Fetch guild queue player node
  * @param node Guild queue node resolvable
  */
 declare function usePlayer<Meta = unknown>(): GuildQueuePlayerNode<Meta> | null;
-declare function usePlayer<Meta = unknown>(node: NodeResolvable): GuildQueuePlayerNode<Meta> | null;
 
 /**
  * Fetch guild queue
  * @param node Guild queue node resolvable
  */
 declare function useQueue<Meta = unknown>(): GuildQueue<Meta> | null;
-declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta> | null;
 
-/**
- * Fetch main player instance
- * @deprecated
- */
-declare function useMasterPlayer(): Player;
 /**
  * Fetch main player instance
  */
@@ -1842,7 +1832,6 @@ type MetadataDispatch<T> = readonly [() => T, (metadata: T | SetterFN$1<T, T>) =
  * @param node Guild queue node resolvable
  */
 declare function useMetadata<T = unknown>(): MetadataDispatch<T>;
-declare function useMetadata<T = unknown>(node: NodeResolvable): MetadataDispatch<T>;
 
 interface TimelineDispatcherOptions {
     ignoreFilters: boolean;
@@ -1852,7 +1841,7 @@ interface TimelineDispatcherOptions {
  * @param node Guild queue node resolvable
  * @param options Options for timeline dispatcher
  */
-declare function useTimeline(node?: NodeResolvable, options?: Partial<TimelineDispatcherOptions>): {
+declare function useTimeline(options?: Partial<TimelineDispatcherOptions>): {
     readonly timestamp: PlayerTimestamp;
     readonly volume: number;
     readonly paused: boolean;
@@ -1882,24 +1871,8 @@ type VolumeDispatch = readonly [() => number, (volume: number | SetterFN) => boo
  * @param node Guild queue node resolvable
  */
 declare function useVolume(): VolumeDispatch;
-declare function useVolume(node: NodeResolvable): VolumeDispatch;
-
-declare const instances: Collection<string, Player>;
 
-declare const getPlayer: () => Player | null;
-interface HooksCtx {
-    guild: Guild;
-}
-declare const getQueue: <T = unknown>(node: NodeResolvable) => GuildQueue<T> | null;
-interface HookDeclarationContext {
-    getQueue: typeof getQueue;
-    getPlayer: typeof getPlayer;
-    instances: typeof instances;
-}
-type HookDeclaration<T extends (...args: any[]) => any> = (context: HookDeclarationContext) => T;
-declare function createHook<T extends HookDeclaration<(...args: any[]) => any>>(hook: T): ReturnType<T>;
-
-declare const knownExtractorKeys: readonly ["SpotifyExtractor", "AppleMusicExtractor", "SoundCloudExtractor", "YouTubeExtractor", "VimeoExtractor", "ReverbnationExtractor", "AttachmentExtractor"];
+declare const knownExtractorKeys: readonly ["SpotifyExtractor", "AppleMusicExtractor", "SoundCloudExtractor", "VimeoExtractor", "ReverbnationExtractor", "AttachmentExtractor"];
 type ExtractorLoaderOptionDict = {
     [K in (typeof knownExtractorKeys)[number]]?: ConstructorParameters<typeof _discord_player_extractor[K]>[1];
 };
@@ -2129,10 +2102,6 @@ declare class BaseExtractor<T extends object = object> {
      * @param message The debug message
      */
     debug(message: string): boolean;
-    /**
-     * IP rotator instance, if available
-     */
-    get routePlanner(): IPRotator | null;
     /**
      * A flag to indicate `Demuxable` stream support for `opus`/`ogg/opus`/`webm/opus` formats.
      */
@@ -2311,42 +2280,8 @@ declare class VoiceUtils {
     getConnection(guild: Snowflake, group?: string): VoiceConnection | undefined;
 }
 
-declare class IPBlock {
-    block: string;
-    usage: number;
-    readonly cidr: string;
-    readonly cidrSize: number;
-    constructor(block: string);
-    consume(): void;
-}
-interface IPRotationConfig {
-    /**
-     * IP blocks to use
-     */
-    blocks: string[];
-    /**
-     * IPs to exclude
-     */
-    exclude?: string[];
-    /**
-     * Max retries to find an IP that is not excluded
-     */
-    maxRetries?: number;
-}
-declare class IPRotator {
-    #private;
-    config: IPRotationConfig;
-    blocks: IPBlock[];
-    failures: Map<string, number>;
-    MAX_NEXT_RETRIES: number;
-    constructor(config: IPRotationConfig);
-    getIP(): {
-        ip: string;
-        family: 4 | 6;
-    };
-    isFailedOrExcluded(ip: string): boolean;
-    addFailed(ip: string): void;
-    static getRandomIP(address: string, start?: number, end?: number): string;
+interface HooksCtx {
+    guild: Guild;
 }
 
 interface PlayerNodeInitializationResult<T = unknown> {
@@ -2370,7 +2305,6 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * The version of discord-player
      */
     static readonly version: string;
-    static _singletonKey: symbol;
     /**
      * The unique identifier of this player instance
      */
@@ -2399,10 +2333,6 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * The player events channel
      */
     events: PlayerEventsEmitter<GuildQueueEvents<any>>;
-    /**
-     * The route planner
-     */
-    routePlanner: IPRotator | null;
     /**
      * The player version
      */
@@ -2427,26 +2357,12 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      */
     onVoiceStateUpdate(handler: VoiceStateHandler): void;
     debug(m: string): boolean;
-    /**
-     * Creates discord-player singleton instance.
-     * @param client The client that instantiated player
-     * @param options Player initializer options
-     */
-    static singleton(client: Client, options?: Omit<PlayerInitOptions, 'ignoreInstance'>): Player;
     /**
      * Creates new discord-player instance.
      * @param client The client that instantiated player
      * @param options Player initializer options
      */
-    static create(client: Client, options?: Omit<PlayerInitOptions, 'ignoreInstance'>): Player;
-    /**
-     * Get all active master player instances
-     */
-    static getAllPlayers(): Player[];
-    /**
-     * Clear all master player instances
-     */
-    static clearAllPlayers(): void;
+    static create(client: Client, options?: PlayerInitOptions): Player;
     /**
      * The current query cache provider in use
      */
@@ -2470,7 +2386,6 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      *
      * // outputs something like
      * // {
-     * //   instances: number,
      * //   queuesCount: number,
      * //   queryCacheEnabled: boolean,
      * //   queues: [
@@ -2483,7 +2398,6 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * ```
      */
     generateStatistics(): {
-        instances: number;
         queuesCount: number;
         queryCacheEnabled: boolean;
         queues: GuildQueueStatisticsMetadata[];
@@ -3095,10 +3009,6 @@ interface PlaylistJSON {
     tracks: TrackJSON[];
 }
 interface PlayerInitOptions {
-    /**
-     * The options passed to `ytdl-core`.
-     */
-    ytdlOptions?: downloadOptions;
     /**
      * The voice connection timeout
      */
@@ -3123,10 +3033,6 @@ interface PlayerInitOptions {
      * Query cache provider
      */
     queryCache?: QueryCacheProvider<any> | null;
-    /**
-     * Ignore player instance
-     */
-    ignoreInstance?: boolean;
     /**
      * Use legacy version of ffmpeg
      */
@@ -3135,10 +3041,6 @@ interface PlayerInitOptions {
      * Set bridge provider
      */
     bridgeProvider?: BridgeProvider;
-    /**
-     * IP rotator config
-     */
-    ipconfig?: IPRotationConfig;
     /**
      * Skip ffmpeg process when possible
      */
@@ -3329,6 +3231,67 @@ declare class QueryResolver {
     static validateURL(q: string): boolean;
 }
 
+interface PackageJSON {
+    name: string;
+    version: string;
+}
+type MaybeNull<T> = T | null;
+interface DependenciesReport {
+    core: {
+        'discord-player': string;
+        'discord-voip': string;
+    };
+    libopus: {
+        mediaplex: MaybeNull<string>;
+        '@discordjs/opus': MaybeNull<string>;
+        '@evan/opus': MaybeNull<string>;
+        opusscript: MaybeNull<string>;
+        'node-opus': MaybeNull<string>;
+    };
+    libsodium: {
+        'sodium-native': MaybeNull<string>;
+        sodium: MaybeNull<string>;
+        'libsodium-wrappers': MaybeNull<string>;
+        'sodium-javascript': MaybeNull<string>;
+        '@stablelib/xchacha20poly1305': MaybeNull<string>;
+    };
+    ffmpeg: FFmpegReport;
+}
+type FFmpegReport = Record<FFmpegLib, MaybeNull<{
+    version: string;
+    hasLibopus: boolean;
+}>>;
+/**
+ * A utility to generate a report of the dependencies used by the discord-player module.
+ */
+declare const DependencyReportGenerator: {
+    /**
+     * Finds the package.json file of a package.
+     * @param dir - The directory to start searching from
+     * @param packageName - The name of the package to find
+     * @param depth - The maximum depth to search
+     * @returns The package.json file, or null if not found
+     */
+    findPackageJSON(dir: string, packageName: string, depth: number): PackageJSON | null;
+    /**
+     * Tries to find the version of a dependency.
+     * @param name - The package to find the version of
+     * @param maxLookupDepth - The maximum depth to search for the package.json file
+     * @returns The version of the package, or null if not found
+     */
+    version(name: string, maxLookupDepth?: number): string | null;
+    /**
+     * Generates a report of the dependencies used by the discord-player module.
+     * @returns The report object
+     */
+    generate(): DependenciesReport;
+    /**
+     * Generates a string representation of the dependencies report.
+     * @returns The string representation
+     */
+    generateString(): string;
+};
+
 declare const version: string;
 
-export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AsyncQueueExceptionHandler, AudioFilters, BaseExtractor, Context, ContextReceiver, CreateStreamOps, DiscordPlayerQueryResultCache, Encodable, EqualizerConfigurationPreset, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorLoaderOptionDict, ExtractorResolvable, ExtractorSearchContext, ExtractorSession, ExtractorStreamable, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, GuildQueueStatistics, GuildQueueStatisticsMetadata, HookDeclaration, HookDeclarationContext, IPBlock, IPRotationConfig, IPRotator, LrcGetParams, LrcGetResult, LrcLib, LrcSearchParams, LrcSearchResult, MetadataDispatch, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheProvider, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RequestEntity, ResolvedQuery, ResourcePlayOptions, Runtime, RuntimeType, SearchOptions, SearchQueryType, SearchResult, SearchResultData, SequentialBucket, SerializedPlaylist, SerializedTrack, SerializedType, SetterFN$1 as SetterFN, SkipOptions, StreamConfig, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSkipReason, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceStateHandler, VoiceUtils, WithMetadata, createContext, createErisCompat, createFFmpegStream, createHook, decode, deserialize, encode, isErisProxy, onAfterCreateStream, onBeforeCreateStream, serialize, tryIntoThumbnailString, useContext, useHistory, useMainPlayer, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };
+export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AsyncQueueExceptionHandler, AudioFilters, BaseExtractor, Context, ContextReceiver, CreateStreamOps, DependenciesReport, DependencyReportGenerator, DiscordPlayerQueryResultCache, Encodable, EqualizerConfigurationPreset, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorLoaderOptionDict, ExtractorResolvable, ExtractorSearchContext, ExtractorSession, ExtractorStreamable, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegReport, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, GuildQueueStatistics, GuildQueueStatisticsMetadata, LrcGetParams, LrcGetResult, LrcLib, LrcSearchParams, LrcSearchResult, MaybeNull, MetadataDispatch, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PackageJSON, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheProvider, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RequestEntity, ResolvedQuery, ResourcePlayOptions, Runtime, RuntimeType, SearchOptions, SearchQueryType, SearchResult, SearchResultData, SequentialBucket, SerializedPlaylist, SerializedTrack, SerializedType, SetterFN$1 as SetterFN, SkipOptions, StreamConfig, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSkipReason, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceStateHandler, VoiceUtils, WithMetadata, createContext, createErisCompat, createFFmpegStream, decode, deserialize, encode, isErisProxy, onAfterCreateStream, onBeforeCreateStream, serialize, tryIntoThumbnailString, useContext, useHistory, useMainPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };