magmastream 2.9.3-dev.25 → 2.9.3-dev.26

package/dist/statestorage/JsonQueue.d.ts

@@ -0,0 +1,173 @@
+import { Manager } from "../structures/Manager";
+import { IQueue, Track } from "../structures/Types";
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+export declare class JsonQueue implements IQueue {
+    readonly guildId: string;
+    readonly manager: Manager;
+    /**
+     * The base path for the queue files.
+     */
+    private basePath;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    private destroyed;
+    /**
+     * @param guildId The guild ID.
+     * @param manager The manager.
+     */
+    constructor(guildId: string, manager: Manager);
+    /**
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
+     */
+    add(track: Track | Track[], offset?: number): Promise<void>;
+    /**
+     * @param track The track to add.
+     */
+    addPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * Clears the queue.
+     */
+    clear(): Promise<void>;
+    /**
+     * Clears the previous tracks.
+     */
+    clearPrevious(): Promise<void>;
+    /**
+     * Removes the first track from the queue.
+     */
+    dequeue(): Promise<Track | undefined>;
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy(): Promise<void>;
+    /**
+     * @returns The total duration of the queue.
+     */
+    duration(): Promise<number>;
+    /**
+     * Adds a track to the front of the queue.
+     */
+    enqueueFront(track: Track | Track[]): Promise<void>;
+    /**
+     * Tests whether all elements in the queue pass the test implemented by the provided function.
+     */
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * Filters the queue.
+     */
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    /**
+     * Finds the first track in the queue that satisfies the provided testing function.
+     */
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    /**
+     * @returns The current track.
+     */
+    getCurrent(): Promise<Track | null>;
+    /**
+     * @returns The previous tracks.
+     */
+    getPrevious(): Promise<Track[]>;
+    /**
+     * @returns The tracks in the queue from start to end.
+     */
+    getSlice(start?: number, end?: number): Promise<Track[]>;
+    /**
+     * @returns The tracks in the queue.
+     */
+    getTracks(): Promise<Track[]>;
+    /**
+     * Maps the queue to a new array.
+     */
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    /**
+     * Modifies the queue at the specified index.
+     */
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    /**
+     * @returns The newest track.
+     */
+    popPrevious(): Promise<Track | null>;
+    /**
+     * Removes a track from the queue.
+     * @param position The position to remove the track at.
+     * @param end The end position to remove the track at.
+     */
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
+    /**
+     * Shuffles the queue by round-robin.
+     */
+    roundRobinShuffle(): Promise<void>;
+    /**
+     * @param track The track to set.
+     */
+    setCurrent(track: Track | null): Promise<void>;
+    /**
+     * @param track The track to set.
+     */
+    setPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * Shuffles the queue.
+     */
+    shuffle(): Promise<void>;
+    /**
+     * @returns The size of the queue.
+     */
+    size(): Promise<number>;
+    /**
+     * Tests whether at least one element in the queue passes the test implemented by the provided function.
+     */
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * @returns The total size of the queue.
+     */
+    totalSize(): Promise<number>;
+    /**
+     * Shuffles the queue by user.
+     */
+    userBlockShuffle(): Promise<void>;
+    /**
+     * @returns The current path.
+     */
+    private get currentPath();
+    /**
+     * @param filePath The file path.
+     */
+    private deleteFile;
+    /**
+     * Ensures the directory exists.
+     */
+    private ensureDir;
+    /**
+     * @returns The queue.
+     */
+    private getQueue;
+    /**
+     * @returns The previous path.
+     */
+    private get previousPath();
+    /**
+     * @returns The queue path.
+     */
+    private get queuePath();
+    /**
+     * @param filePath The file path.
+     * @returns The JSON data.
+     */
+    private readJSON;
+    /**
+     * @param queue The queue.
+     */
+    private setQueue;
+    /**
+     * @param filePath The file path.
+     * @param data The data to write.
+     */
+    private writeJSON;
+}

package/dist/statestorage/JsonQueue.js

@@ -102,8 +102,11 @@ class JsonQueue {
             const tracks = Array.isArray(track) ? track : [track];
             if (!tracks.length)
                 return;
-            const current = await this.getPrevious();
-            const newTracks = tracks.filter((t) => !current.some((p) => p.uri === t.uri));
+            const current = (await this.getPrevious()).filter((p) => p !== null);
+            const validTracks = tracks.filter((t) => t !== null && typeof t.uri === "string");
+            if (!validTracks.length)
+                return;
+            const newTracks = validTracks.filter((t) => !current.some((p) => p.uri === t.uri));
             if (!newTracks.length)
                 return;
             const updated = [...current, ...newTracks];

package/dist/statestorage/MemoryQueue.d.ts

@@ -0,0 +1,154 @@
+import { Manager } from "../structures/Manager";
+import { IQueue, Track } from "../structures/Types";
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+export declare class MemoryQueue extends Array<Track> implements IQueue {
+    /** The current track */
+    current: Track | null;
+    /** The previous tracks */
+    previous: Track[];
+    /** The Manager instance. */
+    manager: Manager;
+    /** The guild ID property. */
+    guildId: string;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    private destroyed;
+    /**
+     * Constructs a new Queue.
+     * @param guildId The guild ID.
+     * @param manager The Manager instance.
+     */
+    constructor(guildId: string, manager: Manager);
+    /**
+     * Adds a track to the queue.
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
+     */
+    add(track: Track | Track[], offset?: number): void;
+    /**
+     * Adds a track to the previous tracks.
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     */
+    addPrevious(track: Track | Track[]): void;
+    /**
+     * Clears the queue.
+     * This will remove all tracks from the queue and emit a state update event.
+     */
+    clear(): void;
+    /**
+     * Clears the previous tracks.
+     */
+    clearPrevious(): void;
+    /**
+     * Removes the first element from the queue.
+     */
+    dequeue(): Track | undefined;
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy(): void;
+    /**
+     * The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
+     */
+    duration(): number;
+    /**
+     * Adds the specified track or tracks to the front of the queue.
+     * @param track The track or tracks to add.
+     */
+    enqueueFront(track: Track | Track[]): void;
+    /**
+     * @returns Whether all elements in the queue satisfy the provided testing function.
+     */
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean;
+    /**
+     * @returns A new array with all elements that pass the test implemented by the provided function.
+     */
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track[];
+    /**
+     * @returns The first element in the queue that satisfies the provided testing function.
+     */
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Track | undefined;
+    /**
+     * @returns The current track.
+     */
+    getCurrent(): Track | null;
+    /**
+     * @returns The previous tracks.
+     */
+    getPrevious(): Track[];
+    /**
+     * @returns The tracks in the queue from start to end.
+     */
+    getSlice(start?: number, end?: number): Track[];
+    /**
+     * @returns The tracks in the queue.
+     */
+    getTracks(): Track[];
+    /**
+     * @returns A new array with the results of calling a provided function on every element in the queue.
+     */
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): T[];
+    /**
+     * Modifies the queue at the specified index.
+     * @param start The index at which to start modifying the queue.
+     * @param deleteCount The number of elements to remove from the queue.
+     * @param items The elements to add to the queue.
+     * @returns The modified queue.
+     */
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Track[];
+    /**
+     * @returns The newest track.
+     */
+    popPrevious(): Track | null;
+    /**
+     * Removes track(s) from the queue.
+     * @param startOrPosition If a single number is provided, it will be treated as the position of the track to remove.
+     *                         If two numbers are provided, they will be used as the start and end of a range of tracks to remove.
+     * @param end Optional, end of the range of tracks to remove.
+     * @returns The removed track(s).
+     */
+    remove(position?: number): Track[];
+    remove(start: number, end: number): Track[];
+    /**
+     * Shuffles the queue to play tracks requested by each user one by one.
+     */
+    roundRobinShuffle(): void;
+    /**
+     * @param track The track to set.
+     */
+    setCurrent(track: Track | null): void;
+    /**
+     * @param tracks The tracks to set.
+     */
+    setPrevious(tracks: Track[]): void;
+    /**
+     * Shuffles the queue.
+     * This will randomize the order of the tracks in the queue and emit a state update event.
+     */
+    shuffle(): void;
+    /**
+     * The size of tracks in the queue.
+     * This does not include the currently playing track.
+     * @returns The size of tracks in the queue.
+     */
+    size(): number;
+    /**
+     * @returns Whether at least one element in the queue satisfies the provided testing function.
+     */
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): boolean;
+    /**
+     * The total size of tracks in the queue including the current track.
+     * This includes the current track if it is not null.
+     * @returns The total size of tracks in the queue including the current track.
+     */
+    totalSize(): number;
+    /**
+     * Shuffles the queue to play tracks requested by each user one block at a time.
+     */
+    userBlockShuffle(): void;
+}

package/dist/statestorage/MemoryQueue.js

@@ -129,12 +129,13 @@ class MemoryQueue extends Array {
     addPrevious(track) {
         try {
             const max = this.manager.options.maxPreviousTracks;
+            this.previous = this.previous.filter((p) => p !== null);
             if (Array.isArray(track)) {
-                const newTracks = track.filter((t) => !this.previous.some((p) => p.identifier === t.identifier));
+                const newTracks = track.filter((t) => !this.previous.some((p) => p?.identifier === t.identifier));
                 this.previous.push(...newTracks);
             }
             else {
-                const exists = this.previous.some((p) => p.identifier === track.identifier);
+                const exists = this.previous.some((p) => p?.identifier === track.identifier);
                 if (!exists) {
                     this.previous.push(track);
                 }
@@ -253,12 +254,14 @@ class MemoryQueue extends Array {
      * @returns The current track.
      */
     getCurrent() {
+        this.current = Utils_1.TrackUtils.revive(this.current);
         return this.current;
     }
     /**
      * @returns The previous tracks.
      */
     getPrevious() {
+        this.previous = this.previous.map((t) => Utils_1.TrackUtils.revive(t));
         return [...this.previous];
     }
     /**
@@ -271,6 +274,7 @@ class MemoryQueue extends Array {
      * @returns The tracks in the queue.
      */
     getTracks() {
+        this.forEach((t) => Utils_1.TrackUtils.revive(t));
         return [...this]; // clone to avoid direct mutation
     }
     /**

package/dist/statestorage/RedisQueue.d.ts

@@ -0,0 +1,178 @@
+import { Manager } from "../structures/Manager";
+import { IQueue, Track } from "../structures/Types";
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+export declare class RedisQueue implements IQueue {
+    readonly guildId: string;
+    readonly manager: Manager;
+    /**
+     * The prefix for the Redis keys.
+     */
+    redisPrefix: string;
+    /**
+     * The Redis instance.
+     */
+    private redis;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    private destroyed;
+    /**
+     * Constructs a new RedisQueue.
+     * @param guildId The guild ID.
+     * @param manager The Manager instance.
+     */
+    constructor(guildId: string, manager: Manager);
+    /**
+     * Adds a track or tracks to the queue.
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
+     */
+    add(track: Track | Track[], offset?: number): Promise<void>;
+    /**
+     * Adds a track or tracks to the previous tracks.
+     * @param track The track or tracks to add.
+     */
+    addPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * Clears the queue.
+     */
+    clear(): Promise<void>;
+    /**
+     * Clears the previous tracks.
+     */
+    clearPrevious(): Promise<void>;
+    /**
+     * Removes the first track from the queue.
+     */
+    dequeue(): Promise<Track | undefined>;
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy(): Promise<void>;
+    /**
+     * @returns The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
+     */
+    duration(): Promise<number>;
+    /**
+     * Adds a track to the front of the queue.
+     * @param track The track or tracks to add.
+     */
+    enqueueFront(track: Track | Track[]): Promise<void>;
+    /**
+     * Whether all tracks in the queue match the specified condition.
+     * @param callback The condition to match.
+     * @returns Whether all tracks in the queue match the specified condition.
+     */
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * Filters the tracks in the queue.
+     * @param callback The condition to match.
+     * @returns The tracks that match the condition.
+     */
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    /**
+     * Finds the first track in the queue that matches the specified condition.
+     * @param callback The condition to match.
+     * @returns The first track that matches the condition.
+     */
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    /**
+     * @returns The current track.
+     */
+    getCurrent(): Promise<Track | null>;
+    /**
+     * @returns The previous tracks.
+     */
+    getPrevious(): Promise<Track[]>;
+    /**
+     * @returns The tracks in the queue from the start to the end.
+     */
+    getSlice(start?: number, end?: number): Promise<Track[]>;
+    /**
+     * @returns The tracks in the queue.
+     */
+    getTracks(): Promise<Track[]>;
+    /**
+     * Maps the tracks in the queue.
+     * @returns The tracks in the queue after the specified index.
+     */
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    /**
+     * Modifies the queue at the specified index.
+     * @param start The start index.
+     * @param deleteCount The number of tracks to delete.
+     * @param items The tracks to insert.
+     * @returns The removed tracks.
+     */
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    /**
+     * Removes the newest track.
+     * @returns The newest track.
+     */
+    popPrevious(): Promise<Track | null>;
+    /**
+     * Removes the track at the specified index.
+     * @param position The position to remove the track at.
+     * @param end The end position to remove the track at.
+     */
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
+    /**
+     * Shuffles the queue round-robin style.
+     */
+    roundRobinShuffle(): Promise<void>;
+    /**
+     * Sets the current track.
+     * @param track The track to set.
+     */
+    setCurrent(track: Track | null): Promise<void>;
+    /**
+     * Sets the previous track(s).
+     * @param track The track to set.
+     */
+    setPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * Shuffles the queue.
+     */
+    shuffle(): Promise<void>;
+    /**
+     * @returns The size of the queue.
+     */
+    size(): Promise<number>;
+    /**
+     * @returns Whether any tracks in the queue match the specified condition.
+     */
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * @returns The total size of tracks in the queue including the current track.
+     */
+    totalSize(): Promise<number>;
+    /**
+     * Shuffles the queue, but keeps the tracks of the same user together.
+     */
+    userBlockShuffle(): Promise<void>;
+    /**
+     * @returns The current key.
+     */
+    private get currentKey();
+    /**
+     * Deserializes a track from a string.
+     */
+    private deserialize;
+    /**
+     * @returns The previous key.
+     */
+    private get previousKey();
+    /**
+     * @returns The queue key.
+     */
+    private get queueKey();
+    /**
+     * Helper to serialize/deserialize Track
+     */
+    private serialize;
+}