@tsparticles/plugin-sounds 3.0.2 → 3.1.0

package/cjs/SoundsInstance.js

@@ -3,13 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SoundsInstance = void 0;
 const engine_1 = require("@tsparticles/engine");
 const utils_js_1 = require("./utils.js");
+const zIndexOffset = 1, rightOffset = 1, minVolume = 0;
 function initImage(data) {
-    const img = document.createElement("img"), { clickCb, container, display, iconOptions, margin, options, pos, rightOffsets } = data, { width, path, svg } = iconOptions;
-    setIconStyle(img, pos.top + margin, pos.right - (margin * (rightOffsets.length + 1) + width + rightOffsets.reduce((a, b) => a + b, 0)), display, options.fullScreen.zIndex + 1, width, margin);
+    const img = document.createElement("img"), { clickCb, container, display, iconOptions, margin, options, pos, rightOffsets } = data, { width, path, style, svg } = iconOptions, defaultAccumulator = 0;
+    setIconStyle(img, pos.top + margin, pos.right -
+        (margin * (rightOffsets.length + rightOffset) +
+            width +
+            rightOffsets.reduce((a, b) => a + b, defaultAccumulator)), display, options.fullScreen.zIndex + zIndexOffset, width, margin, style);
     img.src = path ?? (svg ? `data:image/svg+xml;base64,${btoa(svg)}` : "");
-    const parent = container.canvas.element?.parentNode || document.body;
+    const parent = container.canvas.element?.parentNode ?? document.body;
     parent.append(img);
-    img.addEventListener("click", clickCb);
+    img.addEventListener("click", () => {
+        void clickCb();
+    });
     return img;
 }
 function removeImage(image) {
@@ -18,14 +24,15 @@ function removeImage(image) {
     }
     image.remove();
 }
-function setIconStyle(icon, top, left, display, zIndex, width, margin) {
+function setIconStyle(icon, top, left, display, zIndex, width, margin, style) {
     icon.style.userSelect = "none";
     icon.style.webkitUserSelect = "none";
     icon.style.position = "absolute";
     icon.style.top = `${top + margin}px`;
     icon.style.left = `${left - margin - width}px`;
     icon.style.display = display;
-    icon.style.zIndex = `${zIndex + 1}`;
+    icon.style.zIndex = `${zIndex + zIndexOffset}`;
+    icon.style.cssText += style;
 }
 class SoundsInstance {
     constructor(container, engine) {
@@ -46,12 +53,12 @@ class SoundsInstance {
             }
             for (const event of soundsOptions.events) {
                 const cb = (args) => {
-                    (async () => {
+                    void (async () => {
                         const filterNotValid = event.filter && !event.filter(args);
                         if (this._container !== args.container) {
                             return;
                         }
-                        if (!this._container || this._container.muted || this._container.destroyed) {
+                        if (!this._container || !!this._container.muted || this._container.destroyed) {
                             (0, engine_1.executeOnSingleOrMultiple)(event.event, (item) => {
                                 this._engine.removeEventListener(item, cb);
                             });
@@ -60,21 +67,22 @@ class SoundsInstance {
                         if (filterNotValid) {
                             return;
                         }
+                        const defaultNoteIndex = 0;
                         if (event.audio) {
                             this._playBuffer((0, engine_1.itemFromSingleOrMultiple)(event.audio));
                         }
                         else if (event.melodies) {
                             const melody = (0, engine_1.itemFromArray)(event.melodies);
                             if (melody.melodies.length) {
-                                await Promise.allSettled(melody.melodies.map((m) => this._playNote(m.notes, 0, melody.loop)));
+                                await Promise.allSettled(melody.melodies.map((m) => this._playNote(m.notes, defaultNoteIndex, melody.loop)));
                             }
                             else {
-                                await this._playNote(melody.notes, 0, melody.loop);
+                                await this._playNote(melody.notes, defaultNoteIndex, melody.loop);
                             }
                         }
                         else if (event.notes) {
                             const note = (0, engine_1.itemFromArray)(event.notes);
-                            await this._playNote([note], 0, false);
+                            await this._playNote([note], defaultNoteIndex, false);
                         }
                     })();
                 };
@@ -83,18 +91,15 @@ class SoundsInstance {
                 });
             }
         };
-        this._mute = () => {
-            const container = this._container;
-            if (!container.audioContext) {
-                return;
-            }
+        this._mute = async () => {
+            const container = this._container, audioContext = this._getAudioContext();
             for (const source of this._audioSources) {
                 this._removeAudioSource(source);
             }
             if (this._gain) {
                 this._gain.disconnect();
             }
-            container.audioContext.close();
+            await audioContext.close();
             container.audioContext = undefined;
             this._engine.dispatchEvent("soundsMuted", { container: this._container });
         };
@@ -114,10 +119,10 @@ class SoundsInstance {
             source.start();
         };
         this._playFrequency = async (frequency, duration) => {
-            if (!this._container.audioContext || !this._gain) {
+            if (!this._gain || this._container.muted) {
                 return;
             }
-            const oscillator = this._addOscillator(this._container.audioContext);
+            const audioContext = this._getAudioContext(), oscillator = this._addOscillator(audioContext);
             oscillator.connect(this._gain);
             oscillator.type = "sine";
             oscillator.frequency.value = frequency;
@@ -130,14 +135,13 @@ class SoundsInstance {
             });
         };
         this._playMuteSound = () => {
-            const container = this._container;
-            if (!container.audioContext) {
+            if (this._container.muted) {
                 return;
             }
-            const gain = container.audioContext.createGain();
-            gain.connect(container.audioContext.destination);
+            const audioContext = this._getAudioContext(), gain = audioContext.createGain();
+            gain.connect(audioContext.destination);
             gain.gain.value = 0;
-            const oscillator = container.audioContext.createOscillator();
+            const oscillator = audioContext.createOscillator();
             oscillator.connect(gain);
             oscillator.type = "sine";
             oscillator.frequency.value = 1;
@@ -161,7 +165,8 @@ class SoundsInstance {
                 return this._playNoteValue(notes, noteIdx, idx);
             });
             await ((0, engine_1.isArray)(promises) ? Promise.allSettled(promises) : promises);
-            let nextNoteIdx = noteIdx + 1;
+            const indexOffset = 1;
+            let nextNoteIdx = noteIdx + indexOffset;
             if (loop && nextNoteIdx >= notes.length) {
                 nextNoteIdx = nextNoteIdx % notes.length;
             }
@@ -190,29 +195,31 @@ class SoundsInstance {
         this._removeAudioSource = (source) => {
             source.stop();
             source.disconnect();
-            this._audioSources.splice(this._audioSources.indexOf(source), 1);
+            const deleteCount = 1;
+            this._audioSources.splice(this._audioSources.indexOf(source), deleteCount);
         };
         this._unmute = () => {
             const container = this._container, options = container.actualOptions, soundsOptions = options.sounds;
             if (!soundsOptions) {
                 return;
             }
-            if (!container.audioContext) {
-                container.audioContext = new AudioContext();
-            }
-            const { audioContext } = container;
+            const audioContext = this._getAudioContext();
             if (!this._audioSources) {
                 this._audioSources = [];
             }
             const gain = audioContext.createGain();
             gain.connect(audioContext.destination);
-            gain.gain.value = soundsOptions.volume.value / 100;
+            gain.gain.value = soundsOptions.volume.value / engine_1.percentDenominator;
             this._gain = gain;
             this._initEvents();
             this._engine.dispatchEvent("soundsUnmuted", { container: this._container });
         };
         this._updateMuteIcons = () => {
-            const container = this._container, muteImg = this._muteImg, unmuteImg = this._unmuteImg;
+            const container = this._container, soundsOptions = container.actualOptions.sounds;
+            if (!soundsOptions?.enable || !soundsOptions.icons.enable) {
+                return;
+            }
+            const muteImg = this._muteImg, unmuteImg = this._unmuteImg;
             if (muteImg) {
                 muteImg.style.display = container.muted ? "block" : "none";
             }
@@ -221,13 +228,13 @@ class SoundsInstance {
             }
         };
         this._updateMuteStatus = async () => {
-            const container = this._container;
+            const container = this._container, audioContext = this._getAudioContext();
             if (container.muted) {
-                await container.audioContext?.suspend();
-                this._mute();
+                await audioContext?.suspend();
+                await this._mute();
             }
             else {
-                await container.audioContext?.resume();
+                await audioContext?.resume();
                 this._unmute();
                 this._playMuteSound();
             }
@@ -239,12 +246,12 @@ class SoundsInstance {
             }
             (0, engine_1.clamp)(this._volume, soundsOptions.volume.min, soundsOptions.volume.max);
             let stateChanged = false;
-            if (this._volume <= 0 && !container.muted) {
+            if (this._volume <= minVolume && !container.muted) {
                 this._volume = 0;
                 container.muted = true;
                 stateChanged = true;
             }
-            else if (this._volume > 0 && container.muted) {
+            else if (this._volume > minVolume && container.muted) {
                 container.muted = false;
                 stateChanged = true;
             }
@@ -253,7 +260,7 @@ class SoundsInstance {
                 await this._updateMuteStatus();
             }
             if (this._gain?.gain) {
-                this._gain.gain.value = this._volume / 100;
+                this._gain.gain.value = this._volume / engine_1.percentDenominator;
             }
         };
         this._container = container;
@@ -267,6 +274,20 @@ class SoundsInstance {
         if (!soundsOptions?.enable) {
             return;
         }
+        if (soundsOptions.autoPlay && (0, utils_js_1.isWindowMuted)()) {
+            const firstClickHandler = () => {
+                removeEventListener(engine_1.mouseDownEvent, firstClickHandler);
+                removeEventListener(engine_1.touchStartEvent, firstClickHandler);
+                (0, utils_js_1.unmuteWindow)();
+                void this.unmute();
+            };
+            const listenerOptions = {
+                capture: true,
+                once: true,
+            };
+            addEventListener(engine_1.mouseDownEvent, firstClickHandler, listenerOptions);
+            addEventListener(engine_1.touchStartEvent, firstClickHandler, listenerOptions);
+        }
         this._volume = soundsOptions.volume.value;
         const events = soundsOptions.events;
         this._audioMap = new Map();
@@ -274,16 +295,25 @@ class SoundsInstance {
             if (!event.audio) {
                 continue;
             }
-            (0, engine_1.executeOnSingleOrMultiple)(event.audio, async (audio) => {
+            const promises = (0, engine_1.executeOnSingleOrMultiple)(event.audio, async (audio) => {
                 const response = await fetch(audio.source);
                 if (!response.ok) {
                     return;
                 }
-                const arrayBuffer = await response.arrayBuffer();
-                container.audioContext = new AudioContext();
-                const audioBuffer = await container.audioContext.decodeAudioData(arrayBuffer);
+                const arrayBuffer = await response.arrayBuffer(), audioContext = this._getAudioContext(), audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
                 this._audioMap.set(audio.source, audioBuffer);
             });
+            if (promises instanceof Promise) {
+                await promises;
+            }
+            else {
+                await Promise.allSettled(promises);
+            }
+        }
+    }
+    async mute() {
+        if (!this._container.muted) {
+            await this.toggleMute();
         }
     }
     async start() {
@@ -295,17 +325,14 @@ class SoundsInstance {
         const canvas = container.canvas.element, pos = {
             top: canvas.offsetTop,
             right: canvas.offsetLeft + canvas.offsetWidth,
-        }, { mute, unmute, volumeDown, volumeUp } = soundsOptions.icons, margin = 10;
-        const toggleMute = async () => {
-            container.muted = !container.muted;
-            this._updateMuteIcons();
-            await this._updateMuteStatus();
-        };
+        }, { mute, unmute, volumeDown, volumeUp } = soundsOptions.icons, margin = 10, toggleMute = async () => {
+            await this.toggleMute();
+        }, enableIcons = soundsOptions.icons.enable, display = enableIcons ? "block" : "none";
         this._muteImg = initImage({
             container,
             options,
             pos,
-            display: "block",
+            display,
             iconOptions: mute,
             margin,
             rightOffsets: [volumeDown.width, volumeUp.width],
@@ -325,42 +352,76 @@ class SoundsInstance {
             container,
             options,
             pos,
-            display: "block",
+            display,
             iconOptions: volumeDown,
             margin,
             rightOffsets: [volumeUp.width],
             clickCb: async () => {
-                if (container.muted) {
-                    this._volume = 0;
-                }
-                this._volume -= soundsOptions.volume.step;
-                await this._updateVolume();
+                await this.volumeDown();
             },
         });
         this._volumeUpImg = initImage({
             container,
             options,
             pos,
-            display: "block",
+            display,
             iconOptions: volumeUp,
             margin,
             rightOffsets: [],
             clickCb: async () => {
-                if (container.muted) {
-                    this._volume = 0;
-                }
-                this._volume += soundsOptions.volume.step;
-                await this._updateVolume();
+                await this.volumeUp();
             },
         });
+        if (!(0, utils_js_1.isWindowMuted)() && soundsOptions.autoPlay) {
+            await this.unmute();
+        }
     }
     stop() {
         this._container.muted = true;
-        this._mute();
-        removeImage(this._muteImg);
-        removeImage(this._unmuteImg);
-        removeImage(this._volumeDownImg);
-        removeImage(this._volumeUpImg);
+        void (async () => {
+            await this._mute();
+            removeImage(this._muteImg);
+            removeImage(this._unmuteImg);
+            removeImage(this._volumeDownImg);
+            removeImage(this._volumeUpImg);
+        })();
+    }
+    async toggleMute() {
+        const container = this._container;
+        container.muted = !container.muted;
+        this._updateMuteIcons();
+        await this._updateMuteStatus();
+    }
+    async unmute() {
+        if (this._container.muted) {
+            await this.toggleMute();
+        }
+    }
+    async volumeDown() {
+        const container = this._container, soundsOptions = container.actualOptions.sounds;
+        if (!soundsOptions?.enable) {
+            return;
+        }
+        if (container.muted) {
+            this._volume = 0;
+        }
+        this._volume -= soundsOptions.volume.step;
+        await this._updateVolume();
+    }
+    async volumeUp() {
+        const container = this._container, soundsOptions = container.actualOptions.sounds;
+        if (!soundsOptions?.enable) {
+            return;
+        }
+        this._volume += soundsOptions.volume.step;
+        await this._updateVolume();
+    }
+    _getAudioContext() {
+        const container = this._container;
+        if (!container.audioContext) {
+            container.audioContext = new AudioContext();
+        }
+        return container.audioContext;
     }
 }
 exports.SoundsInstance = SoundsInstance;

package/cjs/index.js

@@ -1,12 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadSoundsPlugin = void 0;
+const engine_1 = require("@tsparticles/engine");
 const Sounds_js_1 = require("./Options/Classes/Sounds.js");
 const SoundsInstance_js_1 = require("./SoundsInstance.js");
+const utils_js_1 = require("./utils.js");
+const generalFirstClickHandler = () => {
+    removeEventListener(engine_1.mouseDownEvent, generalFirstClickHandler);
+    removeEventListener(engine_1.touchStartEvent, generalFirstClickHandler);
+    (0, utils_js_1.unmuteWindow)();
+};
 class SoundsPlugin {
     constructor(engine) {
         this.id = "sounds";
         this._engine = engine;
+        const listenerOptions = {
+            capture: true,
+            once: true,
+        };
+        addEventListener(engine_1.mouseDownEvent, generalFirstClickHandler, listenerOptions);
+        addEventListener(engine_1.touchStartEvent, generalFirstClickHandler, listenerOptions);
     }
     getPlugin(container) {
         return new SoundsInstance_js_1.SoundsInstance(container, this._engine);

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNoteFrequency = void 0;
+exports.unmuteWindow = exports.isWindowMuted = exports.getNoteFrequency = void 0;
 const notes = new Map();
 notes.set("C", [16.35, 32.7, 65.41, 130.81, 261.63, 523.25, 1046.5, 2093.0, 4186.01]);
 notes.set("Db", [17.32, 34.65, 69.3, 138.59, 277.18, 554.37, 1108.73, 2217.46, 4434.92]);
@@ -16,14 +16,23 @@ notes.set("Bb", [29.14, 58.27, 116.54, 233.08, 466.16, 932.33, 1864.66, 3729.31,
 notes.set("B", [30.87, 61.74, 123.47, 246.94, 493.88, 987.77, 1975.53, 3951.07, 7902.13]);
 notes.set("pause", [0]);
 function getNoteFrequency(note) {
-    const regex = /(([A-G]b?)(\d))|pause/i, result = regex.exec(note);
-    if (!result || !result.length) {
+    const regex = /(([A-G]b?)(\d))|pause/i, result = regex.exec(note), groupKey = 2, defaultMatchKey = 0, innerGroupKey = 3;
+    if (!result?.length) {
         return;
     }
-    const noteKey = result[2] || result[0], noteItem = notes.get(noteKey);
+    const noteKey = result[groupKey] || result[defaultMatchKey], noteItem = notes.get(noteKey);
     if (!noteItem) {
         return;
     }
-    return noteItem[parseInt(result[3] || "0")];
+    return noteItem[parseInt(result[innerGroupKey] || "0")];
 }
 exports.getNoteFrequency = getNoteFrequency;
+let muted = true;
+const isWindowMuted = () => {
+    return muted;
+};
+exports.isWindowMuted = isWindowMuted;
+const unmuteWindow = () => {
+    muted = false;
+};
+exports.unmuteWindow = unmuteWindow;

package/esm/Options/Classes/Sounds.js

@@ -3,6 +3,7 @@ import { SoundsIcons } from "./SoundsIcons.js";
 import { SoundsVolume } from "./SoundsVolume.js";
 export class Sounds {
     constructor() {
+        this.autoPlay = true;
         this.enable = false;
         this.events = [];
         this.icons = new SoundsIcons();
@@ -12,6 +13,9 @@ export class Sounds {
         if (!data) {
             return;
         }
+        if (data.autoPlay !== undefined) {
+            this.autoPlay = data.autoPlay;
+        }
         if (data.enable !== undefined) {
             this.enable = data.enable;
         }

package/esm/Options/Classes/SoundsEvent.js

@@ -41,10 +41,11 @@ export class SoundsEvent {
                 return tmp;
             });
         }
-        if (data.filter !== undefined) {
+        if (data.filter) {
             if (isString(data.filter)) {
-                if (isFunction(window[data.filter])) {
-                    this.filter = window[data.filter];
+                const filterFunc = window[data.filter];
+                if (isFunction(filterFunc)) {
+                    this.filter = filterFunc;
                 }
             }
             else {

package/esm/Options/Classes/SoundsIcon.js

@@ -2,6 +2,7 @@ export class SoundsIcon {
     constructor() {
         this.width = 24;
         this.height = 24;
+        this.style = "";
     }
     load(data) {
         if (!data) {

package/esm/Options/Classes/SoundsIcons.js

@@ -5,6 +5,7 @@ export class SoundsIcons {
         this.unmute = new SoundsIcon();
         this.volumeDown = new SoundsIcon();
         this.volumeUp = new SoundsIcon();
+        this.enable = false;
         this.mute.svg = `<?xml version="1.0"?>
 <svg baseProfile="tiny" height="24px" version="1.2" viewBox="0 0 24 24" width="24px"
     xml:space="preserve" xmlns="http://www.w3.org/2000/svg"
@@ -46,6 +47,9 @@ export class SoundsIcons {
         if (!data) {
             return;
         }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
         this.mute.load(data.mute);
         this.unmute.load(data.unmute);
         this.volumeDown.load(data.volumeDown);