@tsparticles/engine 3.2.2 → 3.4.0

package/README.md

@@ -969,10 +969,6 @@ flowchart TD
 
 ## Sponsors
 
-### ScribbleMaps
-
-Huge thanks to [ScribbleMaps](https://www.scribblemaps.com/) for their support on this project.
-
 ### JetBrains
 
 Huge thanks to [JetBrains](https://www.jetbrains.com/?from=tsParticles) for the 2020-2022 Open Source Licenses!

package/browser/Core/Canvas.js

@@ -31,7 +31,7 @@ function setStyle(canvas, style, important = false) {
 export class Canvas {
     constructor(container) {
         this.container = container;
-        this._applyPostDrawUpdaters = (particle) => {
+        this._applyPostDrawUpdaters = particle => {
             for (const updater of this._postDrawUpdaters) {
                 updater.afterDraw?.(particle);
             }
@@ -61,7 +61,7 @@ export class Canvas {
                 plugin.resize?.();
             }
         };
-        this._getPluginParticleColors = (particle) => {
+        this._getPluginParticleColors = particle => {
             let fColor, sColor;
             for (const plugin of this._colorPlugins) {
                 if (!fColor && plugin.particleFillColor) {
@@ -101,7 +101,7 @@ export class Canvas {
                         };
                         resolve();
                     });
-                    img.addEventListener("error", (evt) => {
+                    img.addEventListener("error", evt => {
                         reject(evt.error);
                     });
                     img.src = cover.image;
@@ -162,28 +162,33 @@ export class Canvas {
                         };
                         resolve();
                     });
-                    img.addEventListener("error", (evt) => {
+                    img.addEventListener("error", evt => {
                         reject(evt.error);
                     });
                     img.src = trailFill.image;
                 });
             }
         };
-        this._paintBase = (baseColor) => {
-            this.draw((ctx) => paintBase(ctx, this.size, baseColor));
+        this._paintBase = baseColor => {
+            this.draw(ctx => paintBase(ctx, this.size, baseColor));
         };
         this._paintImage = (image, opacity) => {
-            this.draw((ctx) => paintImage(ctx, this.size, image, opacity));
+            this.draw(ctx => paintImage(ctx, this.size, image, opacity));
         };
         this._repairStyle = () => {
             const element = this.element;
             if (!element) {
                 return;
             }
-            this._safeMutationObserver((observer) => observer.disconnect());
+            this._safeMutationObserver(observer => observer.disconnect());
             this._initStyle();
             this.initBackground();
-            this._safeMutationObserver((observer) => observer.observe(element, { attributes: true }));
+            this._safeMutationObserver(observer => {
+                if (!element || !(element instanceof Node)) {
+                    return;
+                }
+                observer.observe(element, { attributes: true });
+            });
         };
         this._resetOriginalStyle = () => {
             const element = this.element, originalStyle = this._originalStyle;
@@ -192,7 +197,7 @@ export class Canvas {
             }
             setStyle(element, originalStyle);
         };
-        this._safeMutationObserver = (callback) => {
+        this._safeMutationObserver = callback => {
             if (!this._mutationObserver) {
                 return;
             }
@@ -241,7 +246,7 @@ export class Canvas {
             }
         }
         else if (options.clear) {
-            this.draw((ctx) => {
+            this.draw(ctx => {
                 clear(ctx, this.size);
             });
         }
@@ -270,11 +275,11 @@ export class Canvas {
     drawAsync(cb) {
         const ctx = this._context;
         if (!ctx) {
-            return Promise.resolve(undefined);
+            return undefined;
         }
         return cb(ctx);
     }
-    async drawParticle(particle, delta) {
+    drawParticle(particle, delta) {
         if (particle.spawning || particle.destroyed) {
             return;
         }
@@ -293,13 +298,13 @@ export class Canvas {
         if (!fColor && !sColor) {
             return;
         }
-        await this.drawAsync(async (ctx) => {
+        this.draw((ctx) => {
             const container = this.container, options = container.actualOptions, zIndexOptions = particle.options.zIndex, zIndexFactorOffset = 1, zIndexFactor = zIndexFactorOffset - particle.zIndexFactor, zOpacityFactor = zIndexFactor ** zIndexOptions.opacityRate, defaultOpacity = 1, opacity = particle.bubble.opacity ?? particle.opacity?.value ?? defaultOpacity, strokeOpacity = particle.strokeOpacity ?? opacity, zOpacity = opacity * zOpacityFactor, zStrokeOpacity = strokeOpacity * zOpacityFactor, transform = {}, colorStyles = {
                 fill: fColor ? getStyleFromHsl(fColor, zOpacity) : undefined,
             };
             colorStyles.stroke = sColor ? getStyleFromHsl(sColor, zStrokeOpacity) : colorStyles.fill;
             this._applyPreDrawUpdaters(ctx, particle, radius, zOpacity, colorStyles, transform);
-            await drawParticle({
+            drawParticle({
                 container,
                 context: ctx,
                 particle,
@@ -315,15 +320,15 @@ export class Canvas {
             this._applyPostDrawUpdaters(particle);
         });
     }
-    async drawParticlePlugin(plugin, particle, delta) {
-        await this.drawAsync((ctx) => drawParticlePlugin(ctx, plugin, particle, delta));
+    drawParticlePlugin(plugin, particle, delta) {
+        this.draw(ctx => drawParticlePlugin(ctx, plugin, particle, delta));
     }
-    async drawPlugin(plugin, delta) {
-        await this.drawAsync((ctx) => drawPlugin(ctx, plugin, delta));
+    drawPlugin(plugin, delta) {
+        this.draw(ctx => drawPlugin(ctx, plugin, delta));
     }
     async init() {
-        this._safeMutationObserver((obs) => obs.disconnect());
-        this._mutationObserver = safeMutationObserver((records) => {
+        this._safeMutationObserver(obs => obs.disconnect());
+        this._mutationObserver = safeMutationObserver(records => {
             for (const record of records) {
                 if (record.type === "attributes" && record.attributeName === "style") {
                     this._repairStyle();
@@ -340,8 +345,8 @@ export class Canvas {
             getLogger().error(e);
         }
         this.initBackground();
-        this._safeMutationObserver((obs) => {
-            if (!this.element) {
+        this._safeMutationObserver(obs => {
+            if (!this.element || !(this.element instanceof Node)) {
                 return;
             }
             obs.observe(this.element, { attributes: true });
@@ -408,8 +413,8 @@ export class Canvas {
         this.size.height = canvas.offsetHeight;
         this.size.width = canvas.offsetWidth;
         this._context = this.element.getContext("2d");
-        this._safeMutationObserver((obs) => {
-            if (!this.element) {
+        this._safeMutationObserver(obs => {
+            if (!this.element || !(this.element instanceof Node)) {
                 return;
             }
             obs.observe(this.element, { attributes: true });
@@ -419,7 +424,7 @@ export class Canvas {
     }
     paint() {
         const options = this.container.actualOptions;
-        this.draw((ctx) => {
+        this.draw(ctx => {
             if (options.backgroundMask.enable && options.backgroundMask.cover) {
                 clear(ctx, this.size);
                 if (this._coverImage) {
@@ -463,16 +468,16 @@ export class Canvas {
         return true;
     }
     stop() {
-        this._safeMutationObserver((obs) => obs.disconnect());
+        this._safeMutationObserver(obs => obs.disconnect());
         this._mutationObserver = undefined;
-        this.draw((ctx) => clear(ctx, this.size));
+        this.draw(ctx => clear(ctx, this.size));
     }
     async windowResize() {
         if (!this.element || !this.resize()) {
             return;
         }
         const container = this.container, needsRefresh = container.updateActualOptions();
-        await container.particles.setDensity();
+        container.particles.setDensity();
         this._applyResizePlugins();
         if (needsRefresh) {
             await container.refresh();

package/browser/Core/Container.js

@@ -2,6 +2,7 @@ import { errorPrefix, millisecondsToSeconds } from "./Utils/Constants.js";
 import { getLogger, safeIntersectionObserver } from "../Utils/Utils.js";
 import { Canvas } from "./Canvas.js";
 import { EventListeners } from "./Utils/EventListeners.js";
+import { EventType } from "../Enums/Types/EventType.js";
 import { Options } from "../Options/Classes/Options.js";
 import { Particles } from "./Particles.js";
 import { Retina } from "./Retina.js";
@@ -24,7 +25,7 @@ function loadContainerOptions(engine, container, ...sourceOptionsArr) {
 }
 export class Container {
     constructor(engine, id, sourceOptions) {
-        this._intersectionManager = (entries) => {
+        this._intersectionManager = entries => {
             if (!guardCheck(this) || !this.actualOptions.pauseOnOutsideViewport) {
                 return;
             }
@@ -40,7 +41,7 @@ export class Container {
                 }
             }
         };
-        this._nextFrame = async (timestamp) => {
+        this._nextFrame = (timestamp) => {
             try {
                 if (!this._smooth &&
                     this._lastFrameTime !== undefined &&
@@ -56,7 +57,7 @@ export class Container {
                     this.draw(false);
                     return;
                 }
-                await this.particles.draw(delta);
+                this.particles.draw(delta);
                 if (!this.alive()) {
                     this.destroy();
                     return;
@@ -83,6 +84,7 @@ export class Container {
         this._lastFrameTime = 0;
         this.zLayers = 100;
         this.pageHidden = false;
+        this._clickHandlers = new Map();
         this._sourceOptions = sourceOptions;
         this._initialSourceOptions = sourceOptions;
         this.retina = new Retina(this);
@@ -101,8 +103,8 @@ export class Container {
         this._options = loadContainerOptions(this._engine, this);
         this.actualOptions = loadContainerOptions(this._engine, this);
         this._eventListeners = new EventListeners(this);
-        this._intersectionObserver = safeIntersectionObserver((entries) => this._intersectionManager(entries));
-        this._engine.dispatchEvent("containerBuilt", { container: this });
+        this._intersectionObserver = safeIntersectionObserver(entries => this._intersectionManager(entries));
+        this._engine.dispatchEvent(EventType.containerBuilt, { container: this });
     }
     get animationStatus() {
         return !this._paused && !this.pageHidden && guardCheck(this);
@@ -130,8 +132,7 @@ export class Container {
                 y: pos.y * pxRatio,
             }, particles = this.particles.quadTree.queryCircle(posRetina, radius * pxRatio);
             callback(e, particles);
-        };
-        const clickHandler = (e) => {
+        }, clickHandler = (e) => {
             if (!guardCheck(this)) {
                 return;
             }
@@ -140,27 +141,23 @@ export class Container {
                 y: mouseEvent.offsetY || mouseEvent.clientY,
             }, radius = 1;
             clickOrTouchHandler(e, pos, radius);
-        };
-        const touchStartHandler = () => {
+        }, touchStartHandler = () => {
             if (!guardCheck(this)) {
                 return;
             }
             touched = true;
             touchMoved = false;
-        };
-        const touchMoveHandler = () => {
+        }, touchMoveHandler = () => {
             if (!guardCheck(this)) {
                 return;
             }
             touchMoved = true;
-        };
-        const touchEndHandler = (e) => {
+        }, touchEndHandler = (e) => {
             if (!guardCheck(this)) {
                 return;
             }
             if (touched && !touchMoved) {
-                const touchEvent = e;
-                const lengthOffset = 1;
+                const touchEvent = e, lengthOffset = 1;
                 let lastTouch = touchEvent.touches[touchEvent.touches.length - lengthOffset];
                 if (!lastTouch) {
                     lastTouch = touchEvent.changedTouches[touchEvent.changedTouches.length - lengthOffset];
@@ -176,8 +173,7 @@ export class Container {
             }
             touched = false;
             touchMoved = false;
-        };
-        const touchCancelHandler = () => {
+        }, touchCancelHandler = () => {
             if (!guardCheck(this)) {
                 return;
             }
@@ -185,11 +181,14 @@ export class Container {
             touchMoved = false;
         };
         let touched = false, touchMoved = false;
-        el.addEventListener("click", clickHandler);
-        el.addEventListener("touchstart", touchStartHandler);
-        el.addEventListener("touchmove", touchMoveHandler);
-        el.addEventListener("touchend", touchEndHandler);
-        el.addEventListener("touchcancel", touchCancelHandler);
+        this._clickHandlers.set("click", clickHandler);
+        this._clickHandlers.set("touchstart", touchStartHandler);
+        this._clickHandlers.set("touchmove", touchMoveHandler);
+        this._clickHandlers.set("touchend", touchEndHandler);
+        this._clickHandlers.set("touchcancel", touchCancelHandler);
+        for (const [key, handler] of this._clickHandlers) {
+            el.addEventListener(key, handler);
+        }
     }
     addLifeTime(value) {
         this._lifeTime += value;
@@ -204,11 +203,21 @@ export class Container {
     alive() {
         return !this._duration || this._lifeTime <= this._duration;
     }
-    destroy() {
+    clearClickHandlers() {
+        if (!guardCheck(this)) {
+            return;
+        }
+        for (const [key, handler] of this._clickHandlers) {
+            this.interactivity.element?.removeEventListener(key, handler);
+        }
+        this._clickHandlers.clear();
+    }
+    destroy(remove = true) {
         if (!guardCheck(this)) {
             return;
         }
         this.stop();
+        this.clearClickHandlers();
         this.particles.destroy();
         this.canvas.destroy();
         for (const [, effectDrawer] of this.effectDrawers) {
@@ -225,26 +234,28 @@ export class Container {
         }
         this._engine.clearPlugins(this);
         this.destroyed = true;
-        const mainArr = this._engine.dom(), idx = mainArr.findIndex((t) => t === this), minIndex = 0;
-        if (idx >= minIndex) {
-            const deleteCount = 1;
-            mainArr.splice(idx, deleteCount);
+        if (remove) {
+            const mainArr = this._engine.items, idx = mainArr.findIndex(t => t === this), minIndex = 0;
+            if (idx >= minIndex) {
+                const deleteCount = 1;
+                mainArr.splice(idx, deleteCount);
+            }
         }
-        this._engine.dispatchEvent("containerDestroyed", { container: this });
+        this._engine.dispatchEvent(EventType.containerDestroyed, { container: this });
     }
     draw(force) {
         if (!guardCheck(this)) {
             return;
         }
         let refreshTime = force;
-        const frame = async (timestamp) => {
+        const frame = (timestamp) => {
             if (refreshTime) {
                 this._lastFrameTime = undefined;
                 refreshTime = false;
             }
-            await this._nextFrame(timestamp);
+            this._nextFrame(timestamp);
         };
-        this._drawAnimationFrame = requestAnimationFrame((timestamp) => void frame(timestamp));
+        this._drawAnimationFrame = requestAnimationFrame(timestamp => frame(timestamp));
     }
     async export(type, options = {}) {
         for (const [, plugin] of this.plugins) {
@@ -298,13 +309,14 @@ export class Container {
         this.updateActualOptions();
         this.canvas.initBackground();
         this.canvas.resize();
-        this.zLayers = this.actualOptions.zLayers;
-        this._duration = getRangeValue(this.actualOptions.duration) * millisecondsToSeconds;
-        this._delay = getRangeValue(this.actualOptions.delay) * millisecondsToSeconds;
+        const { zLayers, duration, delay, fpsLimit, smooth } = this.actualOptions;
+        this.zLayers = zLayers;
+        this._duration = getRangeValue(duration) * millisecondsToSeconds;
+        this._delay = getRangeValue(delay) * millisecondsToSeconds;
         this._lifeTime = 0;
         const defaultFpsLimit = 120, minFpsLimit = 0;
-        this.fpsLimit = this.actualOptions.fpsLimit > minFpsLimit ? this.actualOptions.fpsLimit : defaultFpsLimit;
-        this._smooth = this.actualOptions.smooth;
+        this.fpsLimit = fpsLimit > minFpsLimit ? fpsLimit : defaultFpsLimit;
+        this._smooth = smooth;
         for (const [, drawer] of this.effectDrawers) {
             await drawer.init?.(this);
         }
@@ -314,13 +326,13 @@ export class Container {
         for (const [, plugin] of this.plugins) {
             await plugin.init?.();
         }
-        this._engine.dispatchEvent("containerInit", { container: this });
+        this._engine.dispatchEvent(EventType.containerInit, { container: this });
         await this.particles.init();
-        await this.particles.setDensity();
+        this.particles.setDensity();
         for (const [, plugin] of this.plugins) {
             plugin.particlesSetup?.();
         }
-        this._engine.dispatchEvent("particlesSetup", { container: this });
+        this._engine.dispatchEvent(EventType.particlesSetup, { container: this });
     }
     async loadTheme(name) {
         if (!guardCheck(this)) {
@@ -346,7 +358,7 @@ export class Container {
         if (!this.pageHidden) {
             this._paused = true;
         }
-        this._engine.dispatchEvent("containerPaused", { container: this });
+        this._engine.dispatchEvent(EventType.containerPaused, { container: this });
     }
     play(force) {
         if (!guardCheck(this)) {
@@ -367,7 +379,7 @@ export class Container {
                 }
             }
         }
-        this._engine.dispatchEvent("containerPlay", { container: this });
+        this._engine.dispatchEvent(EventType.containerPlay, { container: this });
         this.draw(needsUpdate ?? false);
     }
     async refresh() {
@@ -377,12 +389,13 @@ export class Container {
         this.stop();
         return this.start();
     }
-    async reset() {
+    async reset(sourceOptions) {
         if (!guardCheck(this)) {
             return;
         }
-        this._initialSourceOptions = undefined;
-        this._options = loadContainerOptions(this._engine, this);
+        this._initialSourceOptions = sourceOptions;
+        this._sourceOptions = sourceOptions;
+        this._options = loadContainerOptions(this._engine, this, this._initialSourceOptions, this.sourceOptions);
         this.actualOptions = loadContainerOptions(this._engine, this, this._options);
         return this.refresh();
     }
@@ -392,7 +405,7 @@ export class Container {
         }
         await this.init();
         this.started = true;
-        await new Promise((resolve) => {
+        await new Promise(resolve => {
             const start = async () => {
                 this._eventListeners.addListeners();
                 if (this.interactivity.element instanceof HTMLElement && this._intersectionObserver) {
@@ -401,7 +414,7 @@ export class Container {
                 for (const [, plugin] of this.plugins) {
                     await plugin.start?.();
                 }
-                this._engine.dispatchEvent("containerStarted", { container: this });
+                this._engine.dispatchEvent(EventType.containerStarted, { container: this });
                 this.play();
                 resolve();
             };
@@ -432,7 +445,7 @@ export class Container {
             this.plugins.delete(key);
         }
         this._sourceOptions = this._options;
-        this._engine.dispatchEvent("containerStopped", { container: this });
+        this._engine.dispatchEvent(EventType.containerStopped, { container: this });
     }
     updateActualOptions() {
         this.actualOptions.responsive = [];