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

package/cjs/index.js

@@ -13,70 +13,56 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAbsorbersPlugin = void 0;
 const engine_1 = require("@tsparticles/engine");
-const Absorber_1 = require("./Options/Classes/Absorber");
-const Absorbers_1 = require("./Absorbers");
+const Absorber_js_1 = require("./Options/Classes/Absorber.js");
+const Absorbers_js_1 = require("./Absorbers.js");
 class AbsorbersPlugin {
     constructor() {
         this.id = "absorbers";
     }
     getPlugin(container) {
-        return new Absorbers_1.Absorbers(container);
+        return new Absorbers_js_1.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 = (0, engine_1.executeOnSingleOrMultiple)(source.absorbers, (absorber) => {
-                const tmp = new Absorber_1.Absorber();
+                const tmp = new Absorber_js_1.Absorber();
                 tmp.load(absorber);
                 return tmp;
             });
         }
-        options.interactivity.modes.absorbers = (0, engine_1.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) => {
-            const tmp = new Absorber_1.Absorber();
+        options.interactivity.modes.absorbers = (0, engine_1.executeOnSingleOrMultiple)(source?.interactivity?.modes?.absorbers, (absorber) => {
+            const tmp = new Absorber_js_1.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 ((0, engine_1.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 &&
             (0, engine_1.isInArray)("absorber", options.interactivity.events.onClick.mode)) {
             return true;
         }
         return false;
     }
 }
-function loadAbsorbersPlugin(engine) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const plugin = new AbsorbersPlugin();
-        yield engine.addPlugin(plugin);
-    });
+async function loadAbsorbersPlugin(engine, refresh = true) {
+    await engine.addPlugin(new AbsorbersPlugin(), refresh);
 }
 exports.loadAbsorbersPlugin = loadAbsorbersPlugin;
-__exportStar(require("./AbsorberContainer"), exports);
-__exportStar(require("./Enums/AbsorberClickMode"), exports);
+__exportStar(require("./AbsorberContainer.js"), exports);
+__exportStar(require("./Enums/AbsorberClickMode.js"), exports);

package/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/esm/AbsorberInstance.js

@@ -1,10 +1,62 @@
 import { Vector, calcPositionOrRandomFromSize, calcPositionOrRandomFromSizeRanged, getDistance, getDistances, getRandom, getRangeValue, getStyleFromRgb, isPointInside, rangeColorToRgb, } from "@tsparticles/engine";
-import { Absorber } from "./Options/Classes/Absorber";
+import { Absorber } from "./Options/Classes/Absorber.js";
 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,12 +1,12 @@
-import { executeOnSingleOrMultiple, itemFromSingleOrMultiple } from "@tsparticles/engine";
-import { AbsorberInstance } from "./AbsorberInstance";
+import { executeOnSingleOrMultiple, isNumber, itemFromSingleOrMultiple, } from "@tsparticles/engine";
+import { AbsorberInstance } from "./AbsorberInstance.js";
 export class Absorbers {
     constructor(container) {
         this.container = container;
         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,5 +1,5 @@
-import { OptionsColor, setRangeValue } from "@tsparticles/engine";
-import { AbsorberSize } from "./AbsorberSize";
+import { OptionsColor, setRangeValue, } from "@tsparticles/engine";
+import { AbsorberSize } from "./AbsorberSize.js";
 export class Absorber {
     constructor() {
         this.color = new OptionsColor();

package/esm/Options/Classes/AbsorberSize.js

@@ -1,5 +1,5 @@
-import { AbsorberSizeLimit } from "./AbsorberSizeLimit";
-import { ValueWithRandom } from "@tsparticles/engine";
+import { ValueWithRandom, isNumber } from "@tsparticles/engine";
+import { AbsorberSizeLimit } from "./AbsorberSizeLimit.js";
 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,6 +1,6 @@
-import { executeOnSingleOrMultiple, isInArray } from "@tsparticles/engine";
-import { Absorber } from "./Options/Classes/Absorber";
-import { Absorbers } from "./Absorbers";
+import { executeOnSingleOrMultiple, isArray, isInArray, } from "@tsparticles/engine";
+import { Absorber } from "./Options/Classes/Absorber.js";
+import { Absorbers } from "./Absorbers.js";
 class AbsorbersPlugin {
     constructor() {
         this.id = "absorbers";
@@ -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";
+export * from "./AbsorberContainer.js";
+export * from "./Enums/AbsorberClickMode.js";

package/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsparticles/plugin-absorbers",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-beta.1",
   "description": "tsParticles absorbers plugin",
   "homepage": "https://particles.js.org",
   "repository": {
@@ -67,15 +67,28 @@
   "bugs": {
     "url": "https://github.com/matteobruni/tsparticles/issues"
   },
-  "main": "cjs/index.js",
+  "sideEffects": false,
   "jsdelivr": "tsparticles.plugin.absorbers.min.js",
   "unpkg": "tsparticles.plugin.absorbers.min.js",
+  "browser": "browser/index.js",
+  "main": "cjs/index.js",
   "module": "esm/index.js",
   "types": "types/index.d.ts",
-  "publishConfig": {
-    "access": "public"
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "browser": "./browser/index.js",
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js",
+      "umd": "./umd/index.js",
+      "default": "./cjs/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "dependencies": {
-    "@tsparticles/engine": "^3.0.0-alpha.1"
+    "@tsparticles/engine": "^3.0.0-beta.1"
+  },
+  "publishConfig": {
+    "access": "public"
   }
-}
+}