@tsparticles/plugin-absorbers 3.0.0-alpha.1 → 3.0.0-beta.0

package/esm/AbsorberInstance.js

@@ -2,9 +2,61 @@ import { Vector, calcPositionOrRandomFromSize, calcPositionOrRandomFromSizeRange
 import { Absorber } from "./Options/Classes/Absorber";
 export class AbsorberInstance {
     constructor(absorbers, container, options, position) {
-        var _a, _b, _c;
         this.absorbers = absorbers;
         this.container = container;
+        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.create(0, 0);
+                    particle.absorberOrbit.length = getDistance(particle.getPosition(), this.position);
+                    particle.absorberOrbit.angle = getRandom() * Math.PI * 2;
+                }
+                if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
+                    const minSize = Math.min(canvasSize.width, canvasSize.height);
+                    particle.absorberOrbit.length = minSize * (1 + (getRandom() * 0.2 - 0.1));
+                }
+                if (particle.absorberOrbitDirection === undefined) {
+                    particle.absorberOrbitDirection =
+                        particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise";
+                }
+                const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
+                particle.velocity.setTo(Vector.origin);
+                const updateFunc = {
+                    x: orbitDirection === "clockwise" ? Math.cos : Math.sin,
+                    y: orbitDirection === "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 ?? 0) * container.retina.pixelRatio) / 100) *
+                        container.retina.reduceFactor;
+            }
+            else {
+                const addV = Vector.origin;
+                addV.length = v.length;
+                addV.angle = v.angle;
+                particle.velocity.addTo(addV);
+            }
+        };
         this.initialPosition = position ? Vector.create(position.x, position.y) : undefined;
         if (options instanceof Absorber) {
             this.options = options;
@@ -23,12 +75,12 @@ export class AbsorberInstance {
             radius: limit.radius * container.retina.pixelRatio * container.retina.reduceFactor,
             mass: limit.mass,
         };
-        this.color = (_a = rangeColorToRgb(this.options.color)) !== null && _a !== void 0 ? _a : {
+        this.color = rangeColorToRgb(this.options.color) ?? {
             b: 0,
             g: 0,
             r: 0,
         };
-        this.position = (_c = (_b = this.initialPosition) === null || _b === void 0 ? void 0 : _b.copy()) !== null && _c !== void 0 ? _c : this.calcPosition();
+        this.position = this.initialPosition?.copy() ?? this._calcPosition();
     }
     attract(particle) {
         const container = this.container, options = this.options;
@@ -59,14 +111,14 @@ export class AbsorberInstance {
                 }
                 else {
                     particle.needsNewPosition = true;
-                    this.updateParticlePosition(particle, v);
+                    this._updateParticlePosition(particle, v);
                 }
             }
             else {
                 if (options.destroy) {
                     particle.size.value -= sizeFactor;
                 }
-                this.updateParticlePosition(particle, v);
+                this._updateParticlePosition(particle, v);
             }
             if (this.limit.radius <= 0 || this.size < this.limit.radius) {
                 this.size += sizeFactor;
@@ -76,7 +128,7 @@ export class AbsorberInstance {
             }
         }
         else {
-            this.updateParticlePosition(particle, v);
+            this._updateParticlePosition(particle, v);
         }
     }
     draw(context) {
@@ -92,60 +144,6 @@ export class AbsorberInstance {
         this.position =
             initialPosition && isPointInside(initialPosition, this.container.canvas.size, Vector.origin)
                 ? initialPosition
-                : this.calcPosition();
-    }
-    calcPosition() {
-        const exactPosition = calcPositionOrRandomFromSizeRanged({
-            size: this.container.canvas.size,
-            position: this.options.position,
-        });
-        return Vector.create(exactPosition.x, exactPosition.y);
-    }
-    updateParticlePosition(particle, v) {
-        var _a;
-        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.create(0, 0);
-                particle.absorberOrbit.length = getDistance(particle.getPosition(), this.position);
-                particle.absorberOrbit.angle = getRandom() * Math.PI * 2;
-            }
-            if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
-                const minSize = Math.min(canvasSize.width, canvasSize.height);
-                particle.absorberOrbit.length = minSize * (1 + (getRandom() * 0.2 - 0.1));
-            }
-            if (particle.absorberOrbitDirection === undefined) {
-                particle.absorberOrbitDirection =
-                    particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise";
-            }
-            const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
-            particle.velocity.setTo(Vector.origin);
-            const updateFunc = {
-                x: orbitDirection === "clockwise" ? Math.cos : Math.sin,
-                y: orbitDirection === "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 +=
-                ((((_a = particle.retina.moveSpeed) !== null && _a !== void 0 ? _a : 0) * container.retina.pixelRatio) / 100) *
-                    container.retina.reduceFactor;
-        }
-        else {
-            const addV = Vector.origin;
-            addV.length = v.length;
-            addV.angle = v.angle;
-            particle.velocity.addTo(addV);
-        }
+                : this._calcPosition();
     }
 }

package/esm/Absorbers.js

@@ -1,4 +1,4 @@
-import { executeOnSingleOrMultiple, itemFromSingleOrMultiple } from "@tsparticles/engine";
+import { executeOnSingleOrMultiple, isNumber, itemFromSingleOrMultiple, } from "@tsparticles/engine";
 import { AbsorberInstance } from "./AbsorberInstance";
 export class Absorbers {
     constructor(container) {
@@ -6,7 +6,7 @@ export class Absorbers {
         this.array = [];
         this.absorbers = [];
         this.interactivityAbsorbers = [];
-        container.getAbsorber = (idxOrName) => idxOrName === undefined || typeof idxOrName === "number"
+        container.getAbsorber = (idxOrName) => idxOrName === undefined || isNumber(idxOrName)
             ? this.array[idxOrName || 0]
             : this.array.find((t) => t.name === idxOrName);
         container.addAbsorber = (options, position) => this.addAbsorber(options, position);
@@ -24,7 +24,7 @@ export class Absorbers {
     handleClickMode(mode) {
         const absorberOptions = this.absorbers, modeAbsorbers = this.interactivityAbsorbers;
         if (mode === "absorber") {
-            const absorbersModeOptions = itemFromSingleOrMultiple(modeAbsorbers), absorbersOptions = absorbersModeOptions !== null && absorbersModeOptions !== void 0 ? absorbersModeOptions : itemFromSingleOrMultiple(absorberOptions), aPosition = this.container.interactivity.mouse.clickPosition;
+            const absorbersModeOptions = itemFromSingleOrMultiple(modeAbsorbers), absorbersOptions = absorbersModeOptions ?? itemFromSingleOrMultiple(absorberOptions), aPosition = this.container.interactivity.mouse.clickPosition;
             this.addAbsorber(absorbersOptions, aPosition);
         }
     }

package/esm/Options/Classes/Absorber.js

@@ -1,4 +1,4 @@
-import { OptionsColor, setRangeValue } from "@tsparticles/engine";
+import { OptionsColor, setRangeValue, } from "@tsparticles/engine";
 import { AbsorberSize } from "./AbsorberSize";
 export class Absorber {
     constructor() {

package/esm/Options/Classes/AbsorberSize.js

@@ -1,5 +1,5 @@
+import { ValueWithRandom, isNumber } from "@tsparticles/engine";
 import { AbsorberSizeLimit } from "./AbsorberSizeLimit";
-import { ValueWithRandom } from "@tsparticles/engine";
 export class AbsorberSize extends ValueWithRandom {
     constructor() {
         super();
@@ -15,7 +15,7 @@ export class AbsorberSize extends ValueWithRandom {
         if (data.density !== undefined) {
             this.density = data.density;
         }
-        if (typeof data.limit === "number") {
+        if (isNumber(data.limit)) {
             this.limit.radius = data.limit;
         }
         else {

package/esm/index.js

@@ -1,4 +1,4 @@
-import { executeOnSingleOrMultiple, isInArray } from "@tsparticles/engine";
+import { executeOnSingleOrMultiple, isArray, isInArray, } from "@tsparticles/engine";
 import { Absorber } from "./Options/Classes/Absorber";
 import { Absorbers } from "./Absorbers";
 class AbsorbersPlugin {
@@ -9,45 +9,42 @@ class AbsorbersPlugin {
         return new Absorbers(container);
     }
     loadOptions(options, source) {
-        var _a, _b;
         if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
             return;
         }
-        if (source === null || source === void 0 ? void 0 : source.absorbers) {
+        if (source?.absorbers) {
             options.absorbers = executeOnSingleOrMultiple(source.absorbers, (absorber) => {
                 const tmp = new Absorber();
                 tmp.load(absorber);
                 return tmp;
             });
         }
-        options.interactivity.modes.absorbers = executeOnSingleOrMultiple((_b = (_a = source === null || source === void 0 ? void 0 : source.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.absorbers, (absorber) => {
+        options.interactivity.modes.absorbers = executeOnSingleOrMultiple(source?.interactivity?.modes?.absorbers, (absorber) => {
             const tmp = new Absorber();
             tmp.load(absorber);
             return tmp;
         });
     }
     needsPlugin(options) {
-        var _a, _b, _c;
         if (!options) {
             return false;
         }
         const absorbers = options.absorbers;
-        if (absorbers instanceof Array) {
+        if (isArray(absorbers)) {
             return !!absorbers.length;
         }
         else if (absorbers) {
             return true;
         }
-        else if (((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
+        else if (options.interactivity?.events?.onClick?.mode &&
             isInArray("absorber", options.interactivity.events.onClick.mode)) {
             return true;
         }
         return false;
     }
 }
-export async function loadAbsorbersPlugin(engine) {
-    const plugin = new AbsorbersPlugin();
-    await engine.addPlugin(plugin);
+export async function loadAbsorbersPlugin(engine, refresh = true) {
+    await engine.addPlugin(new AbsorbersPlugin(), refresh);
 }
 export * from "./AbsorberContainer";
 export * from "./Enums/AbsorberClickMode";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsparticles/plugin-absorbers",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-beta.0",
   "description": "tsParticles absorbers plugin",
   "homepage": "https://particles.js.org",
   "repository": {
@@ -72,10 +72,11 @@
   "unpkg": "tsparticles.plugin.absorbers.min.js",
   "module": "esm/index.js",
   "types": "types/index.d.ts",
+  "sideEffects": false,
+  "dependencies": {
+    "@tsparticles/engine": "^3.0.0-beta.0"
+  },
   "publishConfig": {
     "access": "public"
-  },
-  "dependencies": {
-    "@tsparticles/engine": "^3.0.0-alpha.1"
   }
-}
+}