magmastream 2.9.3-dev.3 → 2.9.3-dev.31

package/dist/index.js

@@ -11,9 +11,9 @@ tslib_1.__exportStar(require("./structures/Rest"), exports);
 tslib_1.__exportStar(require("./structures/Utils"), exports);
 tslib_1.__exportStar(require("./structures/MagmastreamError"), exports);
 // wrappers
+tslib_1.__exportStar(require("./wrappers/discordeno"), exports);
 tslib_1.__exportStar(require("./wrappers/discord.js"), exports);
 tslib_1.__exportStar(require("./wrappers/eris"), exports);
-tslib_1.__exportStar(require("./wrappers/detritus"), exports);
 tslib_1.__exportStar(require("./wrappers/oceanic"), exports);
 tslib_1.__exportStar(require("./wrappers/seyfert"), exports);
 // types

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

@@ -17,6 +17,10 @@ class JsonQueue {
      * The base path for the queue files.
      */
     basePath;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    destroyed = false;
     /**
      * @param guildId The guild ID.
      * @param manager The manager.
@@ -98,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];
@@ -172,6 +179,27 @@ class JsonQueue {
             console.error(error);
         }
     }
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        try {
+            await Promise.all([this.deleteFile(this.queuePath), this.deleteFile(this.currentPath), this.deleteFile(this.previousPath)]);
+        }
+        catch (err) {
+            console.error(err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_JSON_ERROR,
+                    message: `Failed to destroy JSONQueue for guild ${this.guildId}`,
+                    cause: err,
+                }));
+        }
+    }
     /**
      * @returns The total duration of the queue.
      */
@@ -348,7 +376,7 @@ class JsonQueue {
             const queue = await this.getQueue();
             const userMap = new Map();
             for (const track of queue) {
-                const userId = track.requester.id;
+                const userId = track.requester.id.toString();
                 if (!userMap.has(userId))
                     userMap.set(userId, []);
                 userMap.get(userId).push(track);
@@ -473,7 +501,7 @@ class JsonQueue {
             const queue = await this.getQueue();
             const userMap = new Map();
             for (const track of queue) {
-                const userId = track.requester.id;
+                const userId = track.requester.id.toString();
                 if (!userMap.has(userId))
                     userMap.set(userId, []);
                 userMap.get(userId).push(track);

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

@@ -16,6 +16,10 @@ class MemoryQueue extends Array {
     manager;
     /** The guild ID property. */
     guildId;
+    /**
+     * Whether the queue has been destroyed.
+     */
+    destroyed = false;
     /**
      * Constructs a new Queue.
      * @param guildId The guild ID.
@@ -34,7 +38,7 @@ class MemoryQueue extends Array {
      * @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.
      */
-    async add(track, offset) {
+    add(track, offset) {
         try {
             const isArray = Array.isArray(track);
             const tracks = isArray ? [...track] : [track];
@@ -122,15 +126,16 @@ class MemoryQueue extends Array {
      * 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.
      */
-    async addPrevious(track) {
+    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);
                 }
@@ -154,7 +159,7 @@ class MemoryQueue extends Array {
      * Clears the queue.
      * This will remove all tracks from the queue and emit a state update event.
      */
-    async clear() {
+    clear() {
         try {
             // Capture the current state of the player for event emission.
             const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
@@ -186,20 +191,32 @@ class MemoryQueue extends Array {
     /**
      * Clears the previous tracks.
      */
-    async clearPrevious() {
+    clearPrevious() {
         this.previous = [];
     }
     /**
      * Removes the first element from the queue.
      */
-    async dequeue() {
+    dequeue() {
         return super.shift();
     }
+    /**
+     * Destroys the queue and releases all resources.
+     * After calling this method, the queue must not be used again.
+     */
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.splice(0);
+        this.previous.length = 0;
+        this.current = null;
+    }
     /**
      * The total duration of the queue in milliseconds.
      * This includes the duration of the currently playing track.
      */
-    async duration() {
+    duration() {
         const current = this.current?.duration ?? 0;
         return this.reduce((acc, cur) => acc + (cur.duration || 0), current);
     }
@@ -207,7 +224,7 @@ class MemoryQueue extends Array {
      * Adds the specified track or tracks to the front of the queue.
      * @param track The track or tracks to add.
      */
-    async enqueueFront(track) {
+    enqueueFront(track) {
         if (Array.isArray(track)) {
             this.unshift(...track);
         }
@@ -218,49 +235,52 @@ class MemoryQueue extends Array {
     /**
      * @returns Whether all elements in the queue satisfy the provided testing function.
      */
-    async everyAsync(callback) {
+    everyAsync(callback) {
         return this.every(callback);
     }
     /**
      * @returns A new array with all elements that pass the test implemented by the provided function.
      */
-    async filterAsync(callback) {
+    filterAsync(callback) {
         return this.filter(callback);
     }
     /**
      * @returns The first element in the queue that satisfies the provided testing function.
      */
-    async findAsync(callback) {
+    findAsync(callback) {
         return this.find(callback);
     }
     /**
      * @returns The current track.
      */
-    async getCurrent() {
+    getCurrent() {
+        this.current = Utils_1.TrackUtils.revive(this.current);
         return this.current;
     }
     /**
      * @returns The previous tracks.
      */
-    async getPrevious() {
+    getPrevious() {
+        this.previous = this.previous.map((t) => Utils_1.TrackUtils.revive(t));
         return [...this.previous];
     }
     /**
      * @returns The tracks in the queue from start to end.
      */
-    async getSlice(start, end) {
+    getSlice(start, end) {
         return this.slice(start, end); // Native sync method, still wrapped in a Promise
     }
     /**
      * @returns The tracks in the queue.
      */
-    async getTracks() {
+    getTracks() {
+        this.forEach((t) => Utils_1.TrackUtils.revive(t));
         return [...this]; // clone to avoid direct mutation
     }
     /**
      * @returns A new array with the results of calling a provided function on every element in the queue.
      */
-    async mapAsync(callback) {
+    mapAsync(callback) {
         return this.map(callback);
     }
     /**
@@ -270,16 +290,16 @@ class MemoryQueue extends Array {
      * @param items The elements to add to the queue.
      * @returns The modified queue.
      */
-    async modifyAt(start, deleteCount = 0, ...items) {
+    modifyAt(start, deleteCount = 0, ...items) {
         return super.splice(start, deleteCount, ...items);
     }
     /**
      * @returns The newest track.
      */
-    async popPrevious() {
+    popPrevious() {
         return this.previous.pop() || null; // get newest track
     }
-    async remove(startOrPosition = 0, end) {
+    remove(startOrPosition = 0, end) {
         try {
             const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
             if (typeof end !== "undefined") {
@@ -331,7 +351,7 @@ class MemoryQueue extends Array {
     /**
      * Shuffles the queue to play tracks requested by each user one by one.
      */
-    async roundRobinShuffle() {
+    roundRobinShuffle() {
         try {
             // Capture the current state of the player for event emission.
             const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
@@ -339,11 +359,11 @@ class MemoryQueue extends Array {
             const userTracks = new Map();
             // Group the tracks in the queue by the user that requested them.
             this.forEach((track) => {
-                const user = track.requester.id;
-                if (!userTracks.has(user)) {
-                    userTracks.set(user, []);
+                const userId = track.requester.id.toString();
+                if (!userTracks.has(userId)) {
+                    userTracks.set(userId, []);
                 }
-                userTracks.get(user).push(track);
+                userTracks.get(userId).push(track);
             });
             // Shuffle the tracks of each user.
             userTracks.forEach((tracks) => {
@@ -394,20 +414,20 @@ class MemoryQueue extends Array {
     /**
      * @param track The track to set.
      */
-    async setCurrent(track) {
+    setCurrent(track) {
         this.current = track;
     }
     /**
      * @param tracks The tracks to set.
      */
-    async setPrevious(tracks) {
+    setPrevious(tracks) {
         this.previous = [...tracks];
     }
     /**
      * Shuffles the queue.
      * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    async shuffle() {
+    shuffle() {
         try {
             // Capture the current state of the player for event emission.
             const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
@@ -443,13 +463,13 @@ class MemoryQueue extends Array {
      * This does not include the currently playing track.
      * @returns The size of tracks in the queue.
      */
-    async size() {
+    size() {
         return this.length;
     }
     /**
      * @returns Whether at least one element in the queue satisfies the provided testing function.
      */
-    async someAsync(callback) {
+    someAsync(callback) {
         return this.some(callback);
     }
     /**
@@ -457,24 +477,24 @@ class MemoryQueue extends Array {
      * This includes the current track if it is not null.
      * @returns The total size of tracks in the queue including the current track.
      */
-    async totalSize() {
+    totalSize() {
         return this.length + (this.current ? 1 : 0);
     }
     /**
      * Shuffles the queue to play tracks requested by each user one block at a time.
      */
-    async userBlockShuffle() {
+    userBlockShuffle() {
         try {
             // Capture the current state of the player for event emission.
             const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
             // Group the tracks in the queue by the user that requested them.
             const userTracks = new Map();
             this.forEach((track) => {
-                const user = track.requester.id;
-                if (!userTracks.has(user)) {
-                    userTracks.set(user, []);
+                const userId = track.requester.id.toString();
+                if (!userTracks.has(userId)) {
+                    userTracks.set(userId, []);
                 }
-                userTracks.get(user).push(track);
+                userTracks.get(userId).push(track);
             });
             // Create a new array for the shuffled queue.
             const shuffledQueue = [];