@tsparticles/plugin-absorbers 4.0.0-beta.0 → 4.0.0-beta.10

package/dist_browser_getAbsorbersInstancesManager_js.js

@@ -0,0 +1,30 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v4.0.0-beta.10
+ */
+"use strict";
+/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+(this["webpackChunk_tsparticles_plugin_absorbers"] = this["webpackChunk_tsparticles_plugin_absorbers"] || []).push([["dist_browser_getAbsorbersInstancesManager_js"],{
+
+/***/ "./dist/browser/getAbsorbersInstancesManager.js"
+/*!******************************************************!*\
+  !*** ./dist/browser/getAbsorbersInstancesManager.js ***!
+  \******************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   getAbsorbersInstancesManager: () => (/* binding */ getAbsorbersInstancesManager)\n/* harmony export */ });\nconst instancesManagers = new WeakMap();\nfunction getAbsorbersInstancesManager(e) {\n    const pluginManager = e.pluginManager;\n    let manager = instancesManagers.get(pluginManager);\n    if (!manager) {\n        manager = __webpack_require__.e(/*! import() */ \"dist_browser_AbsorbersInstancesManager_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./AbsorbersInstancesManager.js */ \"./dist/browser/AbsorbersInstancesManager.js\")).then(({ AbsorbersInstancesManager })=>new AbsorbersInstancesManager(pluginManager)).catch((error)=>{\n            instancesManagers.delete(pluginManager);\n            throw error;\n        });\n        instancesManagers.set(pluginManager, manager);\n    }\n    return manager;\n}\n\n\n//# sourceURL=webpack://@tsparticles/plugin-absorbers/./dist/browser/getAbsorbersInstancesManager.js?\n}");
+
+/***/ }
+
+}]);

package/esm/AbsorberInstance.js

@@ -1,6 +1,6 @@
-import { RotateDirection, Vector, calcPositionOrRandomFromSize, calcPositionOrRandomFromSizeRanged, doublePI, getDistance, getDistances, getRandom, getRangeValue, getStyleFromRgb, isPointInside, millisecondsToSeconds, originPoint, percentDenominator, rangeColorToRgb, } from "@tsparticles/engine";
+import { RotateDirection, Vector, calcPositionOrRandomFromSize, calcPositionOrRandomFromSizeRanged, doublePI, getDistance, getDistances, getRandom, getRangeMax, getRangeValue, getStyleFromRgb, half, identity, isPointInside, millisecondsToSeconds, originPoint, 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, maxAngle = doublePI, minVelocity = 0, defaultLifeDelay = 0, minLifeCount = 0, defaultSpawnDelay = 0, defaultLifeCount = -1;
+const squareExp = 2, absorbFactor = 0.033, minOrbitLength = 0, minRadius = 0, minMass = 0, minAngle = 0, maxAngle = doublePI, maxDegreeAngle = 360, angleIncrementFactor = identity / maxDegreeAngle, minVelocity = 0, defaultLifeDelay = 0, minLifeCount = 0, defaultSpawnDelay = 0, defaultLifeCount = -1;
 export class AbsorberInstance {
     color;
     limit;
@@ -14,15 +14,15 @@ export class AbsorberInstance {
     _currentDuration;
     _currentSpawnDelay;
     _duration;
-    _engine;
     _firstSpawn;
     _immortal;
     _lifeCount;
+    _pluginManager;
     _spawnDelay;
     initialPosition;
-    constructor(engine, container, options, position) {
+    constructor(pluginManager, container, options, position) {
         this._container = container;
-        this._engine = engine;
+        this._pluginManager = pluginManager;
         this._currentDuration = 0;
         this._currentSpawnDelay = 0;
         this.initialPosition = position ? Vector.create(position.x, position.y) : undefined;
@@ -42,7 +42,7 @@ export class AbsorberInstance {
             radius: limit.radius * container.retina.pixelRatio * container.retina.reduceFactor,
             mass: limit.mass,
         };
-        this.color = rangeColorToRgb(this._engine, this.options.color) ?? {
+        this.color = rangeColorToRgb(this._pluginManager, this.options.color) ?? {
             b: 0,
             g: 0,
             r: 0,
@@ -68,14 +68,14 @@ export class AbsorberInstance {
                 }
                 else {
                     particle.needsNewPosition = true;
-                    this._updateParticlePosition(particle, v);
+                    this._updateParticlePosition(particle, delta, v);
                 }
             }
             else {
                 if (options.destroy) {
                     particle.size.value -= sizeFactor;
                 }
-                this._updateParticlePosition(particle, v);
+                this._updateParticlePosition(particle, delta, v);
             }
             if (this.limit.radius <= minRadius || this.size < this.limit.radius) {
                 this.size += sizeFactor;
@@ -85,7 +85,7 @@ export class AbsorberInstance {
             }
         }
         else {
-            this._updateParticlePosition(particle, v);
+            this._updateParticlePosition(particle, delta, v);
         }
     }
     draw(context) {
@@ -147,7 +147,7 @@ export class AbsorberInstance {
             this._duration = duration * millisecondsToSeconds;
         }
     };
-    _updateParticlePosition = (particle, v) => {
+    _updateParticlePosition = (particle, delta, v) => {
         if (particle.destroyed) {
             return;
         }
@@ -173,22 +173,16 @@ export class AbsorberInstance {
                 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;
+            const maxSize = getRangeMax(particle.options.size.value) * container.retina.pixelRatio, sizeFactor = particle.options.move.size ? particle.getRadius() / maxSize : identity, deltaFactor = delta.factor || identity, baseSpeed = particle.retina.moveSpeed, moveSpeed = baseSpeed * sizeFactor * deltaFactor * half;
+            particle.position.x = this.position.x + orbitRadius * Math.cos(orbitAngle);
+            particle.position.y =
+                this.position.y +
+                    orbitRadius * (orbitDirection === RotateDirection.clockwise ? identity : -identity) * Math.sin(orbitAngle);
+            particle.absorberOrbit.length = Math.max(minOrbitLength, particle.absorberOrbit.length - v.length);
+            particle.absorberOrbit.angle += moveSpeed * angleIncrementFactor * container.retina.reduceFactor;
         }
         else {
-            const addV = Vector.origin;
-            addV.length = v.length;
-            addV.angle = v.angle;
-            particle.velocity.addTo(addV);
+            particle.velocity.addTo(v);
         }
     };
     play = () => {

package/esm/AbsorbersInstancesManager.js

@@ -2,13 +2,13 @@ import { isNumber } from "@tsparticles/engine";
 const defaultIndex = 0;
 export class AbsorbersInstancesManager {
     _containerArrays;
-    _engine;
-    constructor(engine) {
+    _pluginManager;
+    constructor(pluginManager) {
+        this._pluginManager = pluginManager;
         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);
+        const { AbsorberInstance } = await import("./AbsorberInstance.js"), absorber = new AbsorberInstance(this._pluginManager, container, options, position), array = this.getArray(container);
         array.push(absorber);
         return absorber;
     }

package/esm/getAbsorbersInstancesManager.js

@@ -0,0 +1,15 @@
+const instancesManagers = new WeakMap();
+export function getAbsorbersInstancesManager(e) {
+    const pluginManager = e.pluginManager;
+    let manager = instancesManagers.get(pluginManager);
+    if (!manager) {
+        manager = import("./AbsorbersInstancesManager.js")
+            .then(({ AbsorbersInstancesManager }) => new AbsorbersInstancesManager(pluginManager))
+            .catch((error) => {
+            instancesManagers.delete(pluginManager);
+            throw error;
+        });
+        instancesManagers.set(pluginManager, manager);
+    }
+    return manager;
+}

package/esm/index.js

@@ -1,16 +1,6 @@
+import { loadAbsorbersInteraction } from "./interaction.js";
+import { loadAbsorbersPluginSimple } from "./plugin.js";
 export async function loadAbsorbersPlugin(engine) {
-    engine.checkVersion("4.0.0-beta.0");
-    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);
-        });
-    });
+    await loadAbsorbersPluginSimple(engine);
+    await loadAbsorbersInteraction(engine);
 }

package/esm/interaction.js

@@ -0,0 +1,14 @@
+export async function loadAbsorbersInteraction(engine) {
+    engine.checkVersion("4.0.0-beta.10");
+    await engine.pluginManager.register(async (e) => {
+        const [{ ensureInteractivityPluginLoaded }, { getAbsorbersInstancesManager },] = await Promise.all([
+            import("@tsparticles/plugin-interactivity"),
+            import("./getAbsorbersInstancesManager.js"),
+        ]), pluginManager = e.pluginManager, instancesManager = await getAbsorbersInstancesManager(e);
+        ensureInteractivityPluginLoaded(e);
+        pluginManager.addInteractor?.("externalAbsorbers", async (container) => {
+            const { AbsorbersInteractor } = await import("./AbsorbersInteractor.js");
+            return new AbsorbersInteractor(container, instancesManager);
+        });
+    });
+}

package/esm/plugin.js

@@ -0,0 +1,10 @@
+export async function loadAbsorbersPluginSimple(engine) {
+    engine.checkVersion("4.0.0-beta.10");
+    await engine.pluginManager.register(async (e) => {
+        const [{ getAbsorbersInstancesManager }, { AbsorbersPlugin },] = await Promise.all([
+            import("./getAbsorbersInstancesManager.js"),
+            import("./AbsorbersPlugin.js"),
+        ]), pluginManager = e.pluginManager, instancesManager = await getAbsorbersInstancesManager(e);
+        pluginManager.addPlugin(new AbsorbersPlugin(instancesManager));
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsparticles/plugin-absorbers",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.10",
   "description": "tsParticles absorbers plugin",
   "homepage": "https://particles.js.org",
   "repository": {
@@ -80,14 +80,32 @@
       "browser": "./browser/index.js",
       "import": "./esm/index.js",
       "require": "./cjs/index.js",
-      "umd": "./umd/index.js",
-      "default": "./cjs/index.js"
+      "default": "./esm/index.js"
+    },
+    "./interaction": {
+      "types": "./types/interaction.d.ts",
+      "browser": "./browser/interaction.js",
+      "import": "./esm/interaction.js",
+      "require": "./cjs/interaction.js",
+      "default": "./esm/interaction.js"
+    },
+    "./plugin": {
+      "types": "./types/plugin.d.ts",
+      "browser": "./browser/plugin.js",
+      "import": "./esm/plugin.js",
+      "require": "./cjs/plugin.js",
+      "default": "./esm/plugin.js"
     },
     "./package.json": "./package.json"
   },
-  "dependencies": {
-    "@tsparticles/engine": "4.0.0-beta.0",
-    "@tsparticles/plugin-interactivity": "4.0.0-beta.0"
+  "peerDependencies": {
+    "@tsparticles/engine": "4.0.0-beta.10",
+    "@tsparticles/plugin-interactivity": "4.0.0-beta.10"
+  },
+  "peerDependenciesMeta": {
+    "@tsparticles/plugin-interactivity": {
+      "optional": true
+    }
   },
   "publishConfig": {
     "access": "public"