discord-player 6.5.0 → 6.6.0-dev

package/README.md

@@ -1,6 +1,6 @@
 # Discord Player
 
-Discord Player is a powerful framework for JavaScript and TypeScript, built on top of **[@discord.js/voice](https://npm.im/@discordjs/voice)** library.
+Discord Player is a powerful framework for JavaScript and TypeScript, built on top of **[@discordjs/voice](https://npm.im/@discordjs/voice)** library.
 It provides easy set of customizable tools to develop Discord Music bots.
 
 [![downloadsBadge](https://img.shields.io/npm/dt/discord-player?style=for-the-badge)](https://npmjs.com/discord-player)
@@ -73,6 +73,8 @@ $ yarn add ytdl-core
 $ yarn add play-dl
 # or
 $ yarn add @distube/ytdl-core
+# or
+$ yarn add yt-stream
 ```
 
 Done with all these? Let's write a simple music bot then.

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 import { ListenerSignature, DefaultListener, EventEmitter, Collection, Queue, QueueStrategy } from '@discord-player/utils';
 import * as discord_js from 'discord.js';
 import { User, GuildVoiceChannelResolvable, VoiceChannel, StageChannel, UserResolvable, Guild, VoiceState, VoiceBasedChannel, Snowflake, Client, GuildResolvable } from 'discord.js';
-import * as stream from 'stream';
-import { Readable, Duplex, DuplexOptions } from 'stream';
+import { Readable, Duplex } from 'stream';
 import { RequestOptions } from 'http';
 import * as _discord_player_equalizer from '@discord-player/equalizer';
 import { EqualizerBand, BiquadFilters, PCMFilters, FiltersChain } from '@discord-player/equalizer';
@@ -11,7 +10,7 @@ import * as _discordjs_voice from '@discordjs/voice';
 import { StreamType, AudioPlayerError, AudioResource, VoiceConnection, AudioPlayer, AudioPlayerStatus, EndBehaviorType } from '@discordjs/voice';
 export { AudioPlayer, CreateAudioPlayerOptions, createAudioPlayer } from '@discordjs/voice';
 import { downloadOptions } from 'ytdl-core';
-import childProcess from 'child_process';
+export * from '@discord-player/ffmpeg';
 
 declare class PlayerEventsEmitter<L extends ListenerSignature<L> = DefaultListener> extends EventEmitter<L> {
     requiredEvents: Array<keyof L>;
@@ -340,12 +339,11 @@ interface VoiceEvents {
 declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
     queue: GuildQueue;
     readonly connectionTimeout: number;
-    readonly voiceConnection: VoiceConnection;
-    readonly audioPlayer: AudioPlayer;
+    voiceConnection: VoiceConnection;
+    audioPlayer: AudioPlayer;
     receiver: VoiceReceiverNode;
     channel: VoiceChannel | StageChannel;
     audioResource?: AudioResource<Track> | null;
-    private readyLock;
     dsp: FiltersChain;
     /**
      * Creates new connection object
@@ -827,6 +825,22 @@ declare class FFmpegFilterer<Meta = unknown> {
     #private;
     af: GuildQueueAudioFilters<Meta>;
     constructor(af: GuildQueueAudioFilters<Meta>);
+    /**
+     * Set input args for FFmpeg
+     */
+    setInputArgs(args: string[]): void;
+    /**
+     * Get input args
+     */
+    get inputArgs(): string[];
+    /**
+     * Get encoder args
+     */
+    get encoderArgs(): string[];
+    /**
+     * Get final ffmpeg args
+     */
+    get args(): string[];
     /**
      * Create ffmpeg stream
      * @param source The stream source
@@ -1013,7 +1027,7 @@ declare const GuildQueueEvent: {
     /**
      * Emitted when audio track is added to the queue
      */
-    readonly audioTrackAdd: "audioTrackadd";
+    readonly audioTrackAdd: "audioTrackAdd";
     /**
      * Emitted when audio tracks were added to the queue
      */
@@ -1030,6 +1044,10 @@ declare const GuildQueueEvent: {
      * Emitted when a connection is created
      */
     readonly connection: "connection";
+    /**
+     * Emitted when a voice connection is destroyed
+     */
+    readonly connectionDestroyed: "connectionDestroyed";
     /**
      * Emitted when the bot is disconnected from the channel
      */
@@ -1106,6 +1124,18 @@ declare const GuildQueueEvent: {
      * Audio player will play next track
      */
     readonly willPlayTrack: "willPlayTrack";
+    /**
+     * Emitted when a voice channel is repopulated
+     */
+    readonly channelPopulate: "channelPopulate";
+    /**
+     * Emitted when a queue is successfully created
+     */
+    readonly queueCreate: "queueCreate";
+    /**
+     * Emitted when a queue is deleted
+     */
+    readonly queueDelete: "queueDelete";
 };
 interface GuildQueueEvents<Meta = unknown> {
     /**
@@ -1137,6 +1167,11 @@ interface GuildQueueEvents<Meta = unknown> {
      * @param queue The queue where this event occurred
      */
     connection: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when a connection is destroyed
+     * @param queue The queue where this event occurred
+     */
+    connectionDestroyed: (queue: GuildQueue<Meta>) => unknown;
     /**
      * Emitted when the bot is disconnected from the channel
      * @param queue The queue where this event occurred
@@ -1256,6 +1291,21 @@ interface GuildQueueEvents<Meta = unknown> {
      * @param done Done callback
      */
     willPlayTrack: (queue: GuildQueue<Meta>, track: Track<unknown>, config: StreamConfig, done: () => void) => unknown;
+    /**
+     * Emitted when a voice channel is populated
+     * @param queue The queue where this event occurred
+     */
+    channelPopulate: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when a queue is successfully created
+     * @param queue The queue where this event occurred
+     */
+    queueCreate: (queue: GuildQueue<Meta>) => unknown;
+    /**
+     * Emitted when a queue is successfully deleted
+     * @param queue The queue where this event occurred
+     */
+    queueDelete: (queue: GuildQueue<Meta>) => unknown;
 }
 declare class GuildQueue<Meta = unknown> {
     #private;
@@ -1465,6 +1515,12 @@ declare class GuildQueue<Meta = unknown> {
      * @param options Player node initialization options
      */
     play(track: TrackLike, options?: PlayerNodeInitializerOptions<Meta>): Promise<PlayerNodeInitializationResult<Meta>>;
+    /**
+     * Emit an event on this queue
+     * @param event The event to emit
+     * @param args The args for the event
+     */
+    emit<K extends keyof GuildQueueEvents<Meta>>(event: K, ...args: Parameters<GuildQueueEvents<Meta>[K]>): boolean;
 }
 
 interface GuildQueueStatisticsMetadata {
@@ -1653,6 +1709,7 @@ interface PlayerNodeInitializerOptions<T> extends SearchOptions {
     audioPlayerOptions?: ResourcePlayOptions;
     afterSearch?: (result: SearchResult) => Promise<SearchResult>;
 }
+type VoiceStateHandler = (player: Player, queue: GuildQueue, oldVoiceState: VoiceState, newVoiceState: VoiceState) => Awaited<void>;
 declare class Player extends PlayerEventsEmitter<PlayerEvents> {
     #private;
     static readonly version: string;
@@ -1670,6 +1727,11 @@ declare class Player extends PlayerEventsEmitter<PlayerEvents> {
      * @param {PlayerInitOptions} [options] The player init options
      */
     constructor(client: Client, options?: PlayerInitOptions);
+    /**
+     * Override default voice state update handler
+     * @param handler The handler callback
+     */
+    onVoiceStateUpdate(handler: VoiceStateHandler): void;
     debug(m: string): boolean;
     /**
      * Creates discord-player singleton instance.
@@ -2351,93 +2413,49 @@ declare class QueryResolver {
     static validateURL(q: string): boolean;
 }
 
-type Callback<Args extends Array<unknown>> = (...args: Args) => unknown;
-interface FFmpegInfo {
-    command: string | null;
-    metadata: string | null;
-    version: string | null;
-    isStatic: boolean;
-}
-interface FFmpegOptions extends DuplexOptions {
-    args?: string[];
-    shell?: boolean;
-}
-declare class FFmpeg extends Duplex {
-    /**
-     * FFmpeg version regex
-     */
-    static VersionRegex: RegExp;
-    /**
-     * Spawns ffmpeg process
-     * @param options Spawn options
-     */
-    static spawn({ args, shell }?: {
-        args?: string[] | undefined;
-        shell?: boolean | undefined;
-    }): childProcess.ChildProcessWithoutNullStreams;
-    /**
-     * Check if ffmpeg is available
-     */
-    static isAvailable(): boolean;
-    /**
-     * Safe locate ffmpeg
-     * @param force if it should relocate the command
-     */
-    static locateSafe(force?: boolean): FFmpegInfo | null | undefined;
-    /**
-     * Locate ffmpeg command. Throws error if ffmpeg is not found.
-     * @param force Forcefully reload
-     */
-    static locate(force?: boolean): FFmpegInfo | undefined;
-    /**
-     * Current FFmpeg process
-     */
-    process: childProcess.ChildProcessWithoutNullStreams;
-    /**
-     * Create FFmpeg duplex stream
-     * @param options Options to initialize ffmpeg
-     * @example ```typescript
-     * const ffmpeg = new FFmpeg({
-     *   args: [
-     *     '-analyzeduration', '0',
-     *     '-loglevel', '0',
-     *     '-f', 's16le',
-     *     '-ar', '48000',
-     *     '-ac', '2',
-     *     '-af', 'bass=g=10,acompressor'
-     *   ]
-     * });
-     *
-     * const pcm = input.pipe(ffmpeg);
-     *
-     * pcm.pipe(fs.createWriteStream('./audio.pcm'));
-     * ```
-     */
-    constructor(options?: FFmpegOptions);
-    get _reader(): stream.Readable;
-    get _writer(): stream.Writable;
-    private _copy;
-    _destroy(err: Error | null, cb: Callback<[Error | null]>): unknown;
-    _final(cb: Callback<[]>): void;
-    private _cleanup;
-    toString(): string;
-}
-declare const findFFmpeg: typeof FFmpeg.locate;
-
+/**
+ * Fetch guild queue history
+ * @param node guild queue node resolvable
+ */
 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>(node: NodeResolvable): GuildQueuePlayerNode<Meta> | null;
 
+/**
+ * Fetch guild queue
+ * @param node Guild queue node resolvable
+ */
 declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta> | null;
 
-declare function useMasterPlayer(): Player | null;
+/**
+ * Fetch main player instance
+ * @deprecated
+ */
+declare function useMasterPlayer(): Player | null;
+/**
+ * Fetch main player instance
+ */
+declare function useMainPlayer(): Player | null;
 
-type SetterFN<T, P> = (previous: P) => T;
-declare function useMetadata<T = unknown>(node: NodeResolvable): readonly [() => T, (metadata: T | SetterFN<T, T>) => void];
+type SetterFN$1<T, P> = (previous: P) => T;
+/**
+ * Fetch or manipulate guild queue metadata
+ * @param node Guild queue node resolvable
+ */
+declare function useMetadata<T = unknown>(node: NodeResolvable): readonly [() => T, (metadata: T | SetterFN$1<T, T>) => void];
 
 interface TimelineDispatcherOptions {
     ignoreFilters: boolean;
 }
+/**
+ * Fetch or manipulate current track
+ * @param node Guild queue node resolvable
+ * @param options Options for timeline dispatcher
+ */
 declare function useTimeline(node: NodeResolvable, options?: Partial<TimelineDispatcherOptions>): {
     readonly timestamp: PlayerTimestamp;
     readonly volume: number;
@@ -2449,10 +2467,37 @@ declare function useTimeline(node: NodeResolvable, options?: Partial<TimelineDis
     setPosition(time: number): Promise<boolean>;
 } | null;
 
+/**
+ * Global onAfterCreateStream handler
+ * @param handler The handler callback
+ */
 declare function onAfterCreateStream(handler: OnAfterCreateStreamHandler): void;
 
+/**
+ * Global onBeforeCreateStream handler
+ * @param handler The handler callback
+ */
 declare function onBeforeCreateStream(handler: OnBeforeCreateStreamHandler): void;
 
+type SetterFN = (previous: number) => number;
+/**
+ * Fetch or manipulate player volume
+ * @param node Guild queue node resolvable
+ */
+declare function useVolume(node: NodeResolvable): readonly [() => number, (volume: number | SetterFN) => boolean | undefined];
+
+declare const instances: Collection<string, Player>;
+
+declare const getPlayer: () => Player | null;
+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 version: string;
 
-export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AudioFilters, BaseExtractor, CreateStreamOps, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpeg, FFmpegFilterer, FFmpegInfo, FFmpegOptions, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamConfig, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, WithMetadata, createFFmpegStream, findFFmpeg, onAfterCreateStream, onBeforeCreateStream, useHistory, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, version };
+export { AFilterGraph, AsyncQueue, AsyncQueueAcquisitionOptions, AsyncQueueEntry, AudioFilters, BaseExtractor, CreateStreamOps, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ExtractorExecutionContext, ExtractorExecutionEvents, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvent, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, HookDeclaration, HookDeclarationContext, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerEvent, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerNodeInitializationResult, PlayerNodeInitializerOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamConfig, StreamDispatcher, TimeData, TimelineDispatcherOptions, Track, TrackJSON, TrackLike, TrackResolvable, TrackSource, TypeUtil, Util, VALIDATE_QUEUE_CAP, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceStateHandler, VoiceUtils, WithMetadata, createFFmpegStream, createHook, onAfterCreateStream, onBeforeCreateStream, useHistory, useMainPlayer, useMasterPlayer, useMetadata, usePlayer, useQueue, useTimeline, useVolume, version };