magmastream 2.10.3-dev.2 → 2.10.3

package/dist/structures/Filters.js

@@ -5,12 +5,26 @@ const filtersEqualizers_1 = require("../utils/filtersEqualizers");
 const Enums_1 = require("./Enums");
 const MagmastreamError_1 = require("./MagmastreamError");
 class Filters {
+    static defaultPluginFilterPlugins = ["lavadspx-plugin", "LavaDSPX-Plugin"];
     distortion;
     equalizer;
     karaoke;
     rotation;
     timescale;
+    tremoloOptions;
     vibrato;
+    channelMix;
+    lowPass;
+    highpass;
+    echo;
+    chorus;
+    compressor;
+    flanger;
+    phaser;
+    phonograph;
+    spatial;
+    tape;
+    pluginFilters;
     reverb;
     volume;
     bassBoostlevel;
@@ -23,7 +37,20 @@ class Filters {
         this.karaoke = null;
         this.rotation = null;
         this.timescale = null;
+        this.tremoloOptions = null;
         this.vibrato = null;
+        this.channelMix = null;
+        this.lowPass = null;
+        this.highpass = null;
+        this.echo = null;
+        this.chorus = null;
+        this.compressor = null;
+        this.flanger = null;
+        this.phaser = null;
+        this.phonograph = null;
+        this.spatial = null;
+        this.tape = null;
+        this.pluginFilters = {};
         this.reverb = null;
         this.volume = 1.0;
         this.bassBoostlevel = 0;
@@ -48,19 +75,40 @@ class Filters {
      * of the Filters class for method chaining.
      */
     async updateFilters() {
-        const { distortion, equalizer, karaoke, rotation, timescale, vibrato, volume } = this;
+        const { channelMix, chorus, compressor, distortion, echo, equalizer, flanger, highpass, karaoke, lowPass, phaser, phonograph, pluginFilters, reverb, rotation, spatial, tape, timescale, tremoloOptions, vibrato, volume, } = this;
+        const filters = {
+            distortion,
+            equalizer,
+            karaoke,
+            pluginFilters,
+            rotation,
+            timescale,
+            tremolo: tremoloOptions,
+            vibrato,
+            volume,
+            channelMix,
+            ...(this.player.node.isNodeLink
+                ? {
+                    chorus,
+                    compressor,
+                    echo,
+                    flanger,
+                    lowpass: lowPass,
+                    highpass,
+                    phaser,
+                    phonograph,
+                    reverb,
+                    spatial,
+                    tape,
+                }
+                : {
+                    lowPass,
+                }),
+        };
         try {
             await this.player.node.rest.updatePlayer({
                 data: {
-                    filters: {
-                        distortion,
-                        equalizer,
-                        karaoke,
-                        rotation,
-                        timescale,
-                        vibrato,
-                        volume,
-                    },
+                    filters,
                 },
                 guildId: this.player.guildId,
             });
@@ -78,6 +126,33 @@ class Filters {
         }
         return this;
     }
+    /** Synchronizes local filter state from a NodeLink FiltersChangedEvent without issuing another REST update. */
+    syncFromNode(payload) {
+        const filters = "filters" in payload ? payload.filters : payload;
+        const equalizer = filters.equalizer;
+        this.volume = typeof filters.volume === "number" ? filters.volume : 1.0;
+        this.equalizer = Array.isArray(equalizer) ? equalizer : (equalizer?.bands ?? []);
+        this.karaoke = filters.karaoke ?? null;
+        this.timescale = filters.timescale ?? null;
+        this.tremoloOptions = filters.tremolo ?? null;
+        this.vibrato = filters.vibrato ?? null;
+        this.distortion = filters.distortion ?? null;
+        this.rotation = filters.rotation ?? null;
+        this.channelMix = filters.channelMix ?? null;
+        this.lowPass = filters.lowpass ?? filters.lowPass ?? null;
+        this.highpass = filters.highpass ?? null;
+        this.echo = filters.echo ?? null;
+        this.reverb = filters.reverb ?? null;
+        this.chorus = filters.chorus ?? null;
+        this.compressor = filters.compressor ?? null;
+        this.flanger = filters.flanger ?? null;
+        this.phaser = filters.phaser ?? null;
+        this.phonograph = filters.phonograph ?? null;
+        this.spatial = filters.spatial ?? null;
+        this.tape = filters.tape ?? null;
+        this.pluginFilters = filters.pluginFilters ?? {};
+        return this;
+    }
     /**
      * Applies a specific filter to the player.
      *
@@ -101,6 +176,27 @@ class Filters {
             details: { action: "change" },
         });
     }
+    assertPluginFiltersSupported(pluginNames) {
+        const requiredPlugins = Array.isArray(pluginNames) ? pluginNames : [pluginNames];
+        const availablePlugins = this.player.node.info?.plugins ?? [];
+        const hasRequiredPlugin = requiredPlugins.some((name) => availablePlugins.some((plugin) => plugin.name.toLowerCase() === name.toLowerCase()));
+        if (!hasRequiredPlugin) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_PLUGIN_ERROR,
+                message: `One of the following plugins must be present in the lavalink node: ${requiredPlugins.map((name) => `"${name}"`).join(" or ")}.`,
+                context: { identifier: this.player.node.options.identifier },
+            });
+        }
+    }
+    assertNodeLinkExtraFilterSupported(filterName) {
+        if (this.player.node.isNodeLink)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+            message: `The "${filterName}" filter is only supported on NodeLink nodes.`,
+            context: { identifier: this.player.node.options.identifier },
+        });
+    }
     /**
      * Sets the status of a specific filter.
      *
@@ -146,7 +242,21 @@ class Filters {
         await this.setKaraoke(null);
         await this.setRotation(null);
         await this.setTimescale(null);
+        await this.setTremolo(null);
         await this.setVibrato(null);
+        await this.setChannelMix(null);
+        await this.setLowPass(null);
+        await this.setHighPass(null);
+        await this.setEcho(null);
+        await this.setReverb(null);
+        await this.setChorus(null);
+        await this.setCompressor(null);
+        await this.setFlanger(null);
+        await this.setPhaser(null);
+        await this.setPhonograph(null);
+        await this.setSpatial(null);
+        await this.setTape(null);
+        await this.setPluginFilters({});
         await this.updateFilters();
         this.emitPlayersTasteUpdate(oldPlayer);
         return this;
@@ -215,6 +325,233 @@ class Filters {
         this.emitPlayersTasteUpdate(oldPlayer);
         return this;
     }
+    /**
+     * Sets the tremolo options on the audio.
+     *
+     * @param {TremoloOptions} [tremolo] - The tremolo settings to apply (frequency, depth).
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setTremolo(tremolo) {
+        const oldPlayer = { ...this };
+        await this.applyFilter({ property: "tremoloOptions", value: tremolo ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetTremolo, !!tremolo);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the stereo channel mix options on the audio.
+     *
+     * @param {ChannelMixOptions} [channelMix] - The channel mix settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setChannelMix(channelMix) {
+        const oldPlayer = { ...this };
+        await this.applyFilter({ property: "channelMix", value: channelMix ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetChannelMix, !!channelMix);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the low pass filter options on the audio.
+     *
+     * @param {LowPassOptions} [lowPass] - The low pass settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setLowPass(lowPass) {
+        const oldPlayer = { ...this };
+        await this.applyFilter({ property: "lowPass", value: lowPass ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetLowPass, !!lowPass);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink high pass filter options on the audio.
+     * @param {HighPassOptions} [highpass] - The high pass settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setHighPass(highpass) {
+        const oldPlayer = { ...this };
+        if (highpass)
+            this.assertNodeLinkExtraFilterSupported("highpass");
+        await this.applyFilter({ property: "highpass", value: highpass ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetHighPass, !!highpass);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink echo filter options on the audio.
+     * @param {EchoOptions} [echo] - The echo settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setEcho(echo) {
+        const oldPlayer = { ...this };
+        if (echo)
+            this.assertNodeLinkExtraFilterSupported("echo");
+        await this.applyFilter({ property: "echo", value: echo ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetEcho, !!echo);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink reverb filter options on the audio.
+     * @param {ReverbOptions} [reverb] - The reverb settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setReverb(reverb) {
+        const oldPlayer = { ...this };
+        if (reverb)
+            this.assertNodeLinkExtraFilterSupported("reverb");
+        await this.applyFilter({ property: "reverb", value: reverb ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetReverb, !!reverb);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink chorus filter options on the audio.
+     * @param {ChorusOptions} [chorus] - The chorus settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setChorus(chorus) {
+        const oldPlayer = { ...this };
+        if (chorus)
+            this.assertNodeLinkExtraFilterSupported("chorus");
+        await this.applyFilter({ property: "chorus", value: chorus ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetChorus, !!chorus);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink compressor filter options on the audio.
+     * @param {CompressorOptions} [compressor] - The compressor settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setCompressor(compressor) {
+        const oldPlayer = { ...this };
+        if (compressor)
+            this.assertNodeLinkExtraFilterSupported("compressor");
+        await this.applyFilter({ property: "compressor", value: compressor ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetCompressor, !!compressor);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink flanger filter options on the audio.
+     * @param {FlangerOptions} [flanger] - The flanger settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setFlanger(flanger) {
+        const oldPlayer = { ...this };
+        if (flanger)
+            this.assertNodeLinkExtraFilterSupported("flanger");
+        await this.applyFilter({ property: "flanger", value: flanger ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetFlanger, !!flanger);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink phaser filter options on the audio.
+     * @param {PhaserOptions} [phaser] - The phaser settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setPhaser(phaser) {
+        const oldPlayer = { ...this };
+        if (phaser)
+            this.assertNodeLinkExtraFilterSupported("phaser");
+        await this.applyFilter({ property: "phaser", value: phaser ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetPhaser, !!phaser);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink phonograph filter options on the audio.
+     * @param {PhonographOptions} [phonograph] - The phonograph settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setPhonograph(phonograph) {
+        const oldPlayer = { ...this };
+        if (phonograph)
+            this.assertNodeLinkExtraFilterSupported("phonograph");
+        await this.applyFilter({ property: "phonograph", value: phonograph ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetPhonograph, !!phonograph);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink spatial filter options on the audio.
+     * @param {SpatialOptions} [spatial] - The spatial settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setSpatial(spatial) {
+        const oldPlayer = { ...this };
+        if (spatial)
+            this.assertNodeLinkExtraFilterSupported("spatial");
+        await this.applyFilter({ property: "spatial", value: spatial ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetSpatial, !!spatial);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    /**
+     * Sets the NodeLink tape filter options on the audio.
+     * @param {TapeOptions} [tape] - The tape settings to apply.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setTape(tape) {
+        const oldPlayer = { ...this };
+        if (tape)
+            this.assertNodeLinkExtraFilterSupported("tape");
+        await this.applyFilter({ property: "tape", value: tape ?? null });
+        this.setFilterStatus(Enums_1.AvailableFilters.SetTape, !!tape);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
+    async setNodeLinkHighPass(highpass) {
+        return this.setHighPass(highpass);
+    }
+    async setNodeLinkEcho(echo) {
+        return this.setEcho(echo);
+    }
+    async setNodeLinkReverb(reverb) {
+        return this.setReverb(reverb);
+    }
+    async setNodeLinkChorus(chorus) {
+        return this.setChorus(chorus);
+    }
+    async setNodeLinkCompressor(compressor) {
+        return this.setCompressor(compressor);
+    }
+    async setNodeLinkFlanger(flanger) {
+        return this.setFlanger(flanger);
+    }
+    async setNodeLinkPhaser(phaser) {
+        return this.setPhaser(phaser);
+    }
+    async setNodeLinkPhonograph(phonograph) {
+        return this.setPhonograph(phonograph);
+    }
+    async setNodeLinkSpatial(spatial) {
+        return this.setSpatial(spatial);
+    }
+    async setNodeLinkTape(tape) {
+        return this.setTape(tape);
+    }
+    /**
+     * Sets plugin-provided filter options on the audio.
+     *
+     * @param {Record<string, unknown>} [pluginFilters] - Plugin filter settings keyed by plugin filter name.
+     * @param {string | string[]} [requiredPluginNames] - The plugin name(s) that can handle the provided filters. Defaults to LavaDSPX.
+     * @returns {Promise<this>} - Returns the current instance of the Filters class for method chaining.
+     */
+    async setPluginFilters(pluginFilters, requiredPluginNames = Filters.defaultPluginFilterPlugins) {
+        const oldPlayer = { ...this };
+        const nextPluginFilters = pluginFilters ?? {};
+        if (Object.keys(nextPluginFilters).length > 0) {
+            this.assertPluginFiltersSupported(requiredPluginNames);
+        }
+        await this.applyFilter({ property: "pluginFilters", value: nextPluginFilters });
+        this.setFilterStatus(Enums_1.AvailableFilters.PluginFilters, Object.keys(nextPluginFilters).length > 0);
+        this.emitPlayersTasteUpdate(oldPlayer);
+        return this;
+    }
     /**
      * Sets the own rotation options effect to the audio.
      *
@@ -557,7 +894,7 @@ class Filters {
      */
     async tremolo(status) {
         const oldPlayer = { ...this };
-        await this.applyFilter({ property: "vibrato", value: status ? { frequency: 5, depth: 0.5 } : null });
+        await this.applyFilter({ property: "tremoloOptions", value: status ? { frequency: 5, depth: 0.5 } : null });
         this.setFilterStatus(Enums_1.AvailableFilters.Tremolo, status);
         this.emitPlayersTasteUpdate(oldPlayer);
         return this;

package/dist/structures/Manager.d.ts

@@ -135,6 +135,15 @@ export declare class Manager extends EventEmitter {
      * @returns A promise that resolves when the player states have been loaded.
      */
     loadPlayerStates(nodeId: string): Promise<void>;
+    private normalizeSearchType;
+    private buildLoadTracksIdentifier;
+    private isNodeLinkSearchSource;
+    private isPrefixedLoadTracksIdentifier;
+    private hasNodeLinkSearchTypeModifier;
+    private requiresNodeLinkSearchNode;
+    private requiresLavalinkSearchNode;
+    private getSearchNode;
+    private getPreferredNode;
     /**
      * Returns the node to use based on the configured `useNode` and `enablePriorityMode` options.
      * If `enablePriorityMode` is true, the node is chosen based on priority, otherwise it is chosen based on the `useNode` option.