@tsparticles/plugin-absorbers 4.0.0-alpha.2 → 4.0.0-alpha.20

package/cjs/AbsorberInstance.js

@@ -1,61 +1,30 @@
-import { RotateDirection, Vector, calcPositionOrRandomFromSize, calcPositionOrRandomFromSizeRanged, getDistance, getDistances, getRandom, getRangeValue, getStyleFromRgb, isPointInside, originPoint, percentDenominator, rangeColorToRgb, } from "@tsparticles/engine";
+import { RotateDirection, Vector, calcPositionOrRandomFromSize, calcPositionOrRandomFromSizeRanged, doublePI, getDistance, getDistances, getRandom, getRangeValue, getStyleFromRgb, isPointInside, millisecondsToSeconds, originPoint, percentDenominator, rangeColorToRgb, } from "@tsparticles/engine";
 import { Absorber } from "./Options/Classes/Absorber.js";
-const squareExp = 2, absorbFactor = 0.033, minOrbitLength = 0, minRadius = 0, minMass = 0, minAngle = 0, double = 2, maxAngle = Math.PI * double, minVelocity = 0;
+const squareExp = 2, absorbFactor = 0.033, minOrbitLength = 0, minRadius = 0, minMass = 0, minAngle = 0, maxAngle = doublePI, minVelocity = 0, defaultLifeDelay = 0, minLifeCount = 0, defaultSpawnDelay = 0, defaultLifeCount = -1;
 export class AbsorberInstance {
-    constructor(container, engine, options, position) {
-        this._calcPosition = () => {
-            const exactPosition = calcPositionOrRandomFromSizeRanged({
-                size: this._container.canvas.size,
-                position: this.options.position,
-            });
-            return Vector.create(exactPosition.x, exactPosition.y);
-        };
-        this._updateParticlePosition = (particle, v) => {
-            if (particle.destroyed) {
-                return;
-            }
-            const container = this._container, canvasSize = container.canvas.size;
-            if (particle.needsNewPosition) {
-                const newPosition = calcPositionOrRandomFromSize({ size: canvasSize });
-                particle.position.setTo(newPosition);
-                particle.velocity.setTo(particle.initialVelocity);
-                particle.absorberOrbit = undefined;
-                particle.needsNewPosition = false;
-            }
-            if (this.options.orbits) {
-                if (particle.absorberOrbit === undefined) {
-                    particle.absorberOrbit = Vector.origin;
-                    particle.absorberOrbit.length = getDistance(particle.getPosition(), this.position);
-                    particle.absorberOrbit.angle = getRandom() * maxAngle;
-                }
-                if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
-                    const minSize = Math.min(canvasSize.width, canvasSize.height), offset = 1, randomOffset = 0.1, randomFactor = 0.2;
-                    particle.absorberOrbit.length = minSize * (offset + (getRandom() * randomFactor - randomOffset));
-                }
-                particle.absorberOrbitDirection ??=
-                    particle.velocity.x >= minVelocity ? RotateDirection.clockwise : RotateDirection.counterClockwise;
-                const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
-                particle.velocity.setTo(Vector.origin);
-                const updateFunc = {
-                    x: orbitDirection === RotateDirection.clockwise ? Math.cos : Math.sin,
-                    y: orbitDirection === RotateDirection.clockwise ? Math.sin : Math.cos,
-                };
-                particle.position.x = this.position.x + orbitRadius * updateFunc.x(orbitAngle);
-                particle.position.y = this.position.y + orbitRadius * updateFunc.y(orbitAngle);
-                particle.absorberOrbit.length -= v.length;
-                particle.absorberOrbit.angle +=
-                    (((particle.retina.moveSpeed ?? minVelocity) * container.retina.pixelRatio) / percentDenominator) *
-                        container.retina.reduceFactor;
-            }
-            else {
-                const addV = Vector.origin;
-                addV.length = v.length;
-                addV.angle = v.angle;
-                particle.velocity.addTo(addV);
-            }
-        };
+    color;
+    limit;
+    mass;
+    name;
+    opacity;
+    options;
+    position;
+    size;
+    _container;
+    _currentDuration;
+    _currentSpawnDelay;
+    _duration;
+    _engine;
+    _firstSpawn;
+    _immortal;
+    _lifeCount;
+    _spawnDelay;
+    initialPosition;
+    constructor(engine, container, options, position) {
         this._container = container;
         this._engine = engine;
+        this._currentDuration = 0;
+        this._currentSpawnDelay = 0;
         this.initialPosition = position ? Vector.create(position.x, position.y) : undefined;
         if (options instanceof Absorber) {
             this.options = options;
@@ -64,7 +33,6 @@ export class AbsorberInstance {
             this.options = new Absorber();
             this.options.load(options);
         }
-        this.dragging = false;
         this.name = this.options.name;
         this.opacity = this.options.opacity;
         this.size = getRangeValue(this.options.size.value) * container.retina.pixelRatio;
@@ -80,29 +48,19 @@ export class AbsorberInstance {
             r: 0,
         };
         this.position = this.initialPosition?.copy() ?? this._calcPosition();
+        this._firstSpawn = !this.options.life.wait;
+        this._lifeCount = this.options.life.count ?? defaultLifeCount;
+        this._immortal = this._lifeCount <= minLifeCount;
+        this._spawnDelay = container.retina.reduceFactor
+            ? (getRangeValue(this.options.life.delay ?? defaultLifeDelay) * millisecondsToSeconds) /
+                container.retina.reduceFactor
+            : Infinity;
     }
-    attract(particle) {
-        const container = this._container, options = this.options;
-        if (options.draggable) {
-            const mouse = container.interactivity.mouse;
-            if (mouse.clicking && mouse.downPosition) {
-                const mouseDist = getDistance(this.position, mouse.downPosition);
-                if (mouseDist <= this.size) {
-                    this.dragging = true;
-                }
-            }
-            else {
-                this.dragging = false;
-            }
-            if (this.dragging && mouse.position) {
-                this.position.x = mouse.position.x;
-                this.position.y = mouse.position.y;
-            }
-        }
-        const pos = particle.getPosition(), { dx, dy, distance } = getDistances(this.position, pos), v = Vector.create(dx, dy);
+    attract(particle, delta) {
+        const container = this._container, options = this.options, pos = particle.getPosition(), { dx, dy, distance } = getDistances(this.position, pos), v = Vector.create(dx, dy);
         v.length = (this.mass / Math.pow(distance, squareExp)) * container.retina.reduceFactor;
         if (distance < this.size + particle.getRadius()) {
-            const sizeFactor = particle.getRadius() * absorbFactor * container.retina.pixelRatio;
+            const sizeFactor = particle.getRadius() * absorbFactor * container.retina.pixelRatio * delta.factor;
             if ((this.size > particle.getRadius() && distance < this.size - particle.getRadius()) ||
                 (particle.absorberOrbit !== undefined && particle.absorberOrbit.length < minOrbitLength)) {
                 if (options.destroy) {
@@ -145,4 +103,101 @@ export class AbsorberInstance {
                 ? initialPosition
                 : this._calcPosition();
     }
+    update(delta) {
+        if (this._firstSpawn) {
+            this._firstSpawn = false;
+            this._currentSpawnDelay = this._spawnDelay ?? defaultSpawnDelay;
+        }
+        if (this._duration !== undefined) {
+            this._currentDuration += delta.value;
+            if (this._currentDuration >= this._duration) {
+                if (!this._immortal) {
+                    this._lifeCount--;
+                }
+                if (this._lifeCount > minLifeCount || this._immortal) {
+                    this.position = this._calcPosition();
+                    this._spawnDelay = this._container.retina.reduceFactor
+                        ? (getRangeValue(this.options.life.delay ?? defaultLifeDelay) * millisecondsToSeconds) /
+                            this._container.retina.reduceFactor
+                        : Infinity;
+                }
+                this._currentDuration -= this._duration;
+                delete this._duration;
+            }
+        }
+        if (this._spawnDelay !== undefined) {
+            this._currentSpawnDelay += delta.value;
+            if (this._currentSpawnDelay >= this._spawnDelay) {
+                this.play();
+                this._currentSpawnDelay -= this._spawnDelay;
+                delete this._spawnDelay;
+            }
+        }
+    }
+    _calcPosition = () => {
+        const exactPosition = calcPositionOrRandomFromSizeRanged({
+            size: this._container.canvas.size,
+            position: this.options.position,
+        });
+        return Vector.create(exactPosition.x, exactPosition.y);
+    };
+    _prepareToDie = () => {
+        const duration = this.options.life.duration !== undefined ? getRangeValue(this.options.life.duration) : undefined, minDuration = 0;
+        if ((this._lifeCount > minLifeCount || this._immortal) && duration !== undefined && duration > minDuration) {
+            this._duration = duration * millisecondsToSeconds;
+        }
+    };
+    _updateParticlePosition = (particle, v) => {
+        if (particle.destroyed) {
+            return;
+        }
+        const container = this._container, canvasSize = container.canvas.size;
+        if (particle.needsNewPosition) {
+            const newPosition = calcPositionOrRandomFromSize({ size: canvasSize });
+            particle.position.setTo(newPosition);
+            particle.velocity.setTo(particle.initialVelocity);
+            particle.absorberOrbit = undefined;
+            particle.needsNewPosition = false;
+        }
+        if (this.options.orbits) {
+            if (particle.absorberOrbit === undefined) {
+                particle.absorberOrbit = Vector.origin;
+                particle.absorberOrbit.length = getDistance(particle.getPosition(), this.position);
+                particle.absorberOrbit.angle = getRandom() * maxAngle;
+            }
+            if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
+                const minSize = Math.min(canvasSize.width, canvasSize.height), offset = 1, randomOffset = 0.1, randomFactor = 0.2;
+                particle.absorberOrbit.length = minSize * (offset + (getRandom() * randomFactor - randomOffset));
+            }
+            particle.absorberOrbitDirection ??=
+                particle.velocity.x >= minVelocity ? RotateDirection.clockwise : RotateDirection.counterClockwise;
+            const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
+            particle.velocity.setTo(Vector.origin);
+            const updateFunc = {
+                x: orbitDirection === RotateDirection.clockwise ? Math.cos : Math.sin,
+                y: orbitDirection === RotateDirection.clockwise ? Math.sin : Math.cos,
+            };
+            particle.position.x = this.position.x + orbitRadius * updateFunc.x(orbitAngle);
+            particle.position.y = this.position.y + orbitRadius * updateFunc.y(orbitAngle);
+            particle.absorberOrbit.length -= v.length;
+            particle.absorberOrbit.angle +=
+                (((particle.retina.moveSpeed ?? minVelocity) * container.retina.pixelRatio) / percentDenominator) *
+                    container.retina.reduceFactor;
+        }
+        else {
+            const addV = Vector.origin;
+            addV.length = v.length;
+            addV.angle = v.angle;
+            particle.velocity.addTo(addV);
+        }
+    };
+    play = () => {
+        if (!((this._lifeCount > minLifeCount || this._immortal || !this.options.life.count) &&
+            (this._firstSpawn || this._currentSpawnDelay >= (this._spawnDelay ?? defaultSpawnDelay)))) {
+            return;
+        }
+        if (this._lifeCount > minLifeCount || this._immortal) {
+            this._prepareToDie();
+        }
+    };
 }

package/cjs/AbsorbersInstancesManager.js

@@ -0,0 +1,49 @@
+import { isNumber } from "@tsparticles/engine";
+const defaultIndex = 0;
+export class AbsorbersInstancesManager {
+    _containerArrays;
+    _engine;
+    constructor(engine) {
+        this._containerArrays = new Map();
+        this._engine = engine;
+    }
+    async addAbsorber(container, options, position) {
+        const { AbsorberInstance } = await import("./AbsorberInstance.js"), absorber = new AbsorberInstance(this._engine, container, options, position), array = this.getArray(container);
+        array.push(absorber);
+        return absorber;
+    }
+    clear(container) {
+        this.initContainer(container);
+        this._containerArrays.set(container, []);
+    }
+    getArray(container) {
+        this.initContainer(container);
+        let array = this._containerArrays.get(container);
+        if (!array) {
+            array = [];
+            this._containerArrays.set(container, array);
+        }
+        return array;
+    }
+    initContainer(container) {
+        if (this._containerArrays.has(container)) {
+            return;
+        }
+        this._containerArrays.set(container, []);
+        container.getAbsorber ??= (idxOrName) => {
+            const array = this.getArray(container);
+            return idxOrName === undefined || isNumber(idxOrName)
+                ? array[idxOrName ?? defaultIndex]
+                : array.find(t => t.name === idxOrName);
+        };
+        container.addAbsorber ??= (options, position) => {
+            return this.addAbsorber(container, options, position);
+        };
+    }
+    removeAbsorber(container, absorber) {
+        const index = this.getArray(container).indexOf(absorber), deleteCount = 1;
+        if (index >= defaultIndex) {
+            this.getArray(container).splice(index, deleteCount);
+        }
+    }
+}

package/cjs/AbsorbersInteractor.js

@@ -0,0 +1,93 @@
+import { ExternalInteractorBase, } from "@tsparticles/plugin-interactivity";
+import { getDistance, isArray, isInArray, itemFromArray, } from "@tsparticles/engine";
+import { Absorber } from "./Options/Classes/Absorber.js";
+const absorbersMode = "absorbers";
+export class AbsorbersInteractor extends ExternalInteractorBase {
+    handleClickMode;
+    _instancesManager;
+    dragging = false;
+    draggingAbsorber;
+    constructor(container, instancesManager) {
+        super(container);
+        this._instancesManager = instancesManager;
+        this._instancesManager.initContainer(container);
+        this.handleClickMode = (mode, interactivityData) => {
+            const container = this.container, options = container.actualOptions, absorbers = options.interactivity.modes.absorbers;
+            if (!absorbers || mode !== absorbersMode) {
+                return;
+            }
+            const { clickPosition } = interactivityData.mouse;
+            if (clickPosition) {
+                const existingAbsorber = instancesManager
+                    .getArray(this.container)
+                    .some(t => getDistance(t.position, clickPosition) < t.size);
+                if (existingAbsorber) {
+                    return;
+                }
+            }
+            const absorbersModeOptions = itemFromArray(absorbers) ?? new Absorber();
+            void this._instancesManager.addAbsorber(container, absorbersModeOptions, clickPosition);
+        };
+    }
+    clear() {
+    }
+    init() {
+    }
+    interact(interactivityData, delta) {
+        for (const particle of this.container.particles.filter(p => this.isEnabled(interactivityData, p))) {
+            for (const absorber of this._instancesManager.getArray(this.container)) {
+                if (absorber.options.draggable) {
+                    const mouse = interactivityData.mouse;
+                    if (mouse.clicking && mouse.downPosition) {
+                        const mouseDist = getDistance(absorber.position, mouse.downPosition);
+                        if (mouseDist <= absorber.size) {
+                            this.dragging = true;
+                            this.draggingAbsorber = absorber;
+                        }
+                    }
+                    else {
+                        this.dragging = false;
+                        this.draggingAbsorber = undefined;
+                    }
+                    if (this.dragging && this.draggingAbsorber == absorber && mouse.position) {
+                        absorber.position.x = mouse.position.x;
+                        absorber.position.y = mouse.position.y;
+                    }
+                }
+                absorber.attract(particle, delta);
+                if (particle.destroyed) {
+                    break;
+                }
+            }
+        }
+    }
+    isEnabled(interactivityData, particle) {
+        const container = this.container, options = container.actualOptions, mouse = interactivityData.mouse, events = (particle?.interactivity ?? options.interactivity).events;
+        if (!mouse.clickPosition || !events.onClick.enable) {
+            return false;
+        }
+        return isInArray(absorbersMode, events.onClick.mode);
+    }
+    loadModeOptions(options, ...sources) {
+        options.absorbers ??= [];
+        for (const source of sources) {
+            if (!source) {
+                continue;
+            }
+            if (isArray(source.absorbers)) {
+                for (const absorber of source.absorbers) {
+                    const tmp = new Absorber();
+                    tmp.load(absorber);
+                    options.absorbers.push(tmp);
+                }
+            }
+            else {
+                const tmp = new Absorber();
+                tmp.load(source.absorbers);
+                options.absorbers.push(tmp);
+            }
+        }
+    }
+    reset() {
+    }
+}

package/cjs/AbsorbersPlugin.js

@@ -1,16 +1,16 @@
-import { executeOnSingleOrMultiple, isArray, isInArray, } from "@tsparticles/engine";
+import { executeOnSingleOrMultiple, isArray, } from "@tsparticles/engine";
 import { Absorber } from "./Options/Classes/Absorber.js";
-import { AbsorberClickMode } from "./Enums/AbsorberClickMode.js";
-import { Absorbers } from "./Absorbers.js";
 export class AbsorbersPlugin {
-    constructor(engine) {
-        this.id = "absorbers";
-        this._engine = engine;
+    id = "absorbers";
+    _instancesManager;
+    constructor(instancesManager) {
+        this._instancesManager = instancesManager;
     }
     async getPlugin(container) {
-        return Promise.resolve(new Absorbers(container, this._engine));
+        const { AbsorbersPluginInstance } = await import("./AbsorbersPluginInstance.js");
+        return new AbsorbersPluginInstance(container, this._instancesManager);
     }
-    loadOptions(options, source) {
+    loadOptions(_container, options, source) {
         if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
             return;
         }
@@ -21,11 +21,6 @@ export class AbsorbersPlugin {
                 return tmp;
             });
         }
-        options.interactivity.modes.absorbers = executeOnSingleOrMultiple(source?.interactivity?.modes?.absorbers, absorber => {
-            const tmp = new Absorber();
-            tmp.load(absorber);
-            return tmp;
-        });
     }
     needsPlugin(options) {
         if (!options) {
@@ -38,10 +33,6 @@ export class AbsorbersPlugin {
         else if (absorbers) {
             return true;
         }
-        else if (options.interactivity?.events?.onClick?.mode &&
-            isInArray(AbsorberClickMode.absorber, options.interactivity.events.onClick.mode)) {
-            return true;
-        }
         return false;
     }
 }

package/cjs/AbsorbersPluginInstance.js

@@ -0,0 +1,42 @@
+import { executeOnSingleOrMultiple, isArray, } from "@tsparticles/engine";
+export class AbsorbersPluginInstance {
+    _container;
+    _instancesManager;
+    constructor(container, instancesManager) {
+        this._container = container;
+        this._instancesManager = instancesManager;
+        this._instancesManager.initContainer(container);
+    }
+    draw(context) {
+        for (const absorber of this._instancesManager.getArray(this._container)) {
+            absorber.draw(context);
+        }
+    }
+    async init() {
+        const absorbers = this._container.actualOptions.absorbers, promises = executeOnSingleOrMultiple(absorbers, async (absorber) => {
+            await this._instancesManager.addAbsorber(this._container, absorber);
+        });
+        if (isArray(promises)) {
+            await Promise.all(promises);
+        }
+        else {
+            await promises;
+        }
+    }
+    particleUpdate(particle, delta) {
+        for (const absorber of this._instancesManager.getArray(this._container)) {
+            absorber.attract(particle, delta);
+            if (particle.destroyed) {
+                break;
+            }
+        }
+    }
+    resize() {
+        for (const absorber of this._instancesManager.getArray(this._container)) {
+            absorber.resize();
+        }
+    }
+    stop() {
+        this._instancesManager.clear(this._container);
+    }
+}

package/cjs/Options/Classes/Absorber.js

@@ -1,6 +1,16 @@
 import { OptionsColor, isNull, setRangeValue, } from "@tsparticles/engine";
+import { AbsorberLife } from "./AbsorberLife.js";
 import { AbsorberSize } from "./AbsorberSize.js";
 export class Absorber {
+    color;
+    destroy;
+    draggable;
+    life;
+    name;
+    opacity;
+    orbits;
+    position;
+    size;
     constructor() {
         this.color = new OptionsColor();
         this.color.value = "#000000";
@@ -8,6 +18,7 @@ export class Absorber {
         this.opacity = 1;
         this.destroy = true;
         this.orbits = false;
+        this.life = new AbsorberLife();
         this.size = new AbsorberSize();
     }
     load(data) {
@@ -20,6 +31,9 @@ export class Absorber {
         if (data.draggable !== undefined) {
             this.draggable = data.draggable;
         }
+        if (data.life !== undefined) {
+            this.life.load(data.life);
+        }
         this.name = data.name;
         if (data.opacity !== undefined) {
             this.opacity = data.opacity;

package/cjs/Options/Classes/AbsorberLife.js

@@ -0,0 +1,27 @@
+import { isNull, setRangeValue } from "@tsparticles/engine";
+export class AbsorberLife {
+    count;
+    delay;
+    duration;
+    wait;
+    constructor() {
+        this.wait = false;
+    }
+    load(data) {
+        if (isNull(data)) {
+            return;
+        }
+        if (data.count !== undefined) {
+            this.count = data.count;
+        }
+        if (data.delay !== undefined) {
+            this.delay = setRangeValue(data.delay);
+        }
+        if (data.duration !== undefined) {
+            this.duration = setRangeValue(data.duration);
+        }
+        if (data.wait !== undefined) {
+            this.wait = data.wait;
+        }
+    }
+}

package/cjs/Options/Classes/AbsorberSize.js

@@ -1,6 +1,8 @@
 import { ValueWithRandom, isNull, isNumber } from "@tsparticles/engine";
 import { AbsorberSizeLimit } from "./AbsorberSizeLimit.js";
 export class AbsorberSize extends ValueWithRandom {
+    density;
+    limit;
     constructor() {
         super();
         this.density = 5;

package/cjs/Options/Classes/AbsorberSizeLimit.js

@@ -1,5 +1,7 @@
 import { isNull } from "@tsparticles/engine";
 export class AbsorberSizeLimit {
+    mass;
+    radius;
     constructor() {
         this.radius = 0;
         this.mass = 0;

package/cjs/Options/Interfaces/IAbsorberLife.js

@@ -0,0 +1 @@
+export {};

package/cjs/index.js

@@ -1,8 +1,16 @@
-export function loadAbsorbersPlugin(engine) {
-    engine.checkVersion("4.0.0-alpha.2");
-    engine.register(async (e) => {
-        const { AbsorbersPlugin } = await import("./AbsorbersPlugin.js");
-        e.addPlugin(new AbsorbersPlugin(e));
+export async function loadAbsorbersPlugin(engine) {
+    engine.checkVersion("4.0.0-alpha.20");
+    await engine.register(async (e) => {
+        const [{ ensureInteractivityPluginLoaded }, { AbsorbersInstancesManager }, { AbsorbersPlugin },] = await Promise.all([
+            import("@tsparticles/plugin-interactivity"),
+            import("./AbsorbersInstancesManager.js"),
+            import("./AbsorbersPlugin.js"),
+        ]), instancesManager = new AbsorbersInstancesManager(e);
+        ensureInteractivityPluginLoaded(e);
+        e.addPlugin(new AbsorbersPlugin(instancesManager));
+        e.addInteractor?.("externalAbsorbers", async (container) => {
+            const { AbsorbersInteractor } = await import("./AbsorbersInteractor.js");
+            return new AbsorbersInteractor(container, instancesManager);
+        });
     });
 }
-export * from "./Enums/AbsorberClickMode.js";