@tsparticles/move-base 3.0.3 → 3.2.0

package/umd/BaseMover.js

@@ -1,65 +1,75 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "@tsparticles/engine", "./Utils.js"], factory);
+        define(["require", "exports", "@tsparticles/engine"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.BaseMover = void 0;
     const engine_1 = require("@tsparticles/engine");
-    const Utils_js_1 = require("./Utils.js");
-    const diffFactor = 2;
+    const diffFactor = 2, defaultSizeFactor = 1, defaultDeltaFactor = 1;
     class BaseMover {
-        constructor() {
-            this._initSpin = (particle) => {
-                const container = particle.container, options = particle.options, spinOptions = options.move.spin;
-                if (!spinOptions.enable) {
-                    return;
-                }
-                const spinPos = spinOptions.position ?? { x: 50, y: 50 }, spinCenter = {
-                    x: spinPos.x * 0.01 * container.canvas.size.width,
-                    y: spinPos.y * 0.01 * container.canvas.size.height,
-                }, pos = particle.getPosition(), distance = (0, engine_1.getDistance)(pos, spinCenter), spinAcceleration = (0, engine_1.getRangeValue)(spinOptions.acceleration);
-                particle.retina.spinAcceleration = spinAcceleration * container.retina.pixelRatio;
-                particle.spin = {
-                    center: spinCenter,
-                    direction: particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise",
-                    angle: particle.velocity.angle,
-                    radius: distance,
-                    acceleration: particle.retina.spinAcceleration,
-                };
-            };
-        }
-        init(particle) {
+        async init(particle) {
             const options = particle.options, gravityOptions = options.move.gravity;
             particle.gravity = {
                 enable: gravityOptions.enable,
                 acceleration: (0, engine_1.getRangeValue)(gravityOptions.acceleration),
                 inverse: gravityOptions.inverse,
             };
-            this._initSpin(particle);
+            const { initSpin } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Utils.js"))) : new Promise((resolve_1, reject_1) => { require(["./Utils.js"], resolve_1, reject_1); }).then(__importStar));
+            initSpin(particle);
+            await Promise.resolve();
         }
         isEnabled(particle) {
             return !particle.destroyed && particle.options.move.enable;
         }
-        move(particle, delta) {
+        async move(particle, delta) {
             const particleOptions = particle.options, moveOptions = particleOptions.move;
             if (!moveOptions.enable) {
                 return;
             }
-            const container = particle.container, pxRatio = container.retina.pixelRatio, slowFactor = (0, Utils_js_1.getProximitySpeedFactor)(particle), baseSpeed = (particle.retina.moveSpeed ??= (0, engine_1.getRangeValue)(moveOptions.speed) * pxRatio) *
-                container.retina.reduceFactor, moveDrift = (particle.retina.moveDrift ??= (0, engine_1.getRangeValue)(particle.options.move.drift) * pxRatio), maxSize = (0, engine_1.getRangeMax)(particleOptions.size.value) * pxRatio, sizeFactor = moveOptions.size ? particle.getRadius() / maxSize : 1, moveSpeed = (baseSpeed * sizeFactor * slowFactor * (delta.factor || 1)) / diffFactor, maxSpeed = particle.retina.maxSpeed ?? container.retina.maxSpeed;
+            const container = particle.container, pxRatio = container.retina.pixelRatio;
+            particle.retina.moveSpeed ??= (0, engine_1.getRangeValue)(moveOptions.speed) * pxRatio;
+            particle.retina.moveDrift ??= (0, engine_1.getRangeValue)(particle.options.move.drift) * pxRatio;
+            const { getProximitySpeedFactor } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Utils.js"))) : new Promise((resolve_2, reject_2) => { require(["./Utils.js"], resolve_2, reject_2); }).then(__importStar)), slowFactor = getProximitySpeedFactor(particle), baseSpeed = particle.retina.moveSpeed * container.retina.reduceFactor, moveDrift = particle.retina.moveDrift, maxSize = (0, engine_1.getRangeMax)(particleOptions.size.value) * pxRatio, sizeFactor = moveOptions.size ? particle.getRadius() / maxSize : defaultSizeFactor, deltaFactor = delta.factor || defaultDeltaFactor, moveSpeed = (baseSpeed * sizeFactor * slowFactor * deltaFactor) / diffFactor, maxSpeed = particle.retina.maxSpeed ?? container.retina.maxSpeed;
             if (moveOptions.spin.enable) {
-                (0, Utils_js_1.spin)(particle, moveSpeed);
+                const { spin } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Utils.js"))) : new Promise((resolve_3, reject_3) => { require(["./Utils.js"], resolve_3, reject_3); }).then(__importStar));
+                spin(particle, moveSpeed);
             }
             else {
-                (0, Utils_js_1.move)(particle, moveOptions, moveSpeed, maxSpeed, moveDrift, delta);
+                const { move } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Utils.js"))) : new Promise((resolve_4, reject_4) => { require(["./Utils.js"], resolve_4, reject_4); }).then(__importStar));
+                await move(particle, moveOptions, moveSpeed, maxSpeed, moveDrift, delta);
             }
-            (0, Utils_js_1.applyDistance)(particle);
+            const { applyDistance } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Utils.js"))) : new Promise((resolve_5, reject_5) => { require(["./Utils.js"], resolve_5, reject_5); }).then(__importStar));
+            applyDistance(particle);
         }
     }
     exports.BaseMover = BaseMover;

package/umd/Utils.js

@@ -9,20 +9,22 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getProximitySpeedFactor = exports.applyPath = exports.spin = exports.move = exports.applyDistance = void 0;
+    exports.initSpin = exports.getProximitySpeedFactor = exports.applyPath = exports.spin = exports.move = exports.applyDistance = void 0;
     const engine_1 = require("@tsparticles/engine");
+    const half = 0.5, minVelocity = 0, identity = 1, moveSpeedFactor = 60, minSpinRadius = 0, spinFactor = 0.01;
     function applyDistance(particle) {
         const initialPosition = particle.initialPosition, { dx, dy } = (0, engine_1.getDistances)(initialPosition, particle.position), dxFixed = Math.abs(dx), dyFixed = Math.abs(dy), { maxDistance } = particle.retina, hDistance = maxDistance.horizontal, vDistance = maxDistance.vertical;
         if (!hDistance && !vDistance) {
             return;
         }
-        if (((hDistance && dxFixed >= hDistance) || (vDistance && dyFixed >= vDistance)) && !particle.misplaced) {
+        const hasHDistance = (hDistance && dxFixed >= hDistance) ?? false, hasVDistance = (vDistance && dyFixed >= vDistance) ?? false;
+        if ((hasHDistance || hasVDistance) && !particle.misplaced) {
             particle.misplaced = (!!hDistance && dxFixed > hDistance) || (!!vDistance && dyFixed > vDistance);
             if (hDistance) {
-                particle.velocity.x = particle.velocity.y * 0.5 - particle.velocity.x;
+                particle.velocity.x = particle.velocity.y * half - particle.velocity.x;
             }
             if (vDistance) {
-                particle.velocity.y = particle.velocity.x * 0.5 - particle.velocity.y;
+                particle.velocity.y = particle.velocity.x * half - particle.velocity.y;
             }
         }
         else if ((!hDistance || dxFixed < hDistance) && (!vDistance || dyFixed < vDistance) && particle.misplaced) {
@@ -30,37 +32,40 @@
         }
         else if (particle.misplaced) {
             const pos = particle.position, vel = particle.velocity;
-            if (hDistance && ((pos.x < initialPosition.x && vel.x < 0) || (pos.x > initialPosition.x && vel.x > 0))) {
+            if (hDistance &&
+                ((pos.x < initialPosition.x && vel.x < minVelocity) || (pos.x > initialPosition.x && vel.x > minVelocity))) {
                 vel.x *= -(0, engine_1.getRandom)();
             }
-            if (vDistance && ((pos.y < initialPosition.y && vel.y < 0) || (pos.y > initialPosition.y && vel.y > 0))) {
+            if (vDistance &&
+                ((pos.y < initialPosition.y && vel.y < minVelocity) || (pos.y > initialPosition.y && vel.y > minVelocity))) {
                 vel.y *= -(0, engine_1.getRandom)();
             }
         }
     }
     exports.applyDistance = applyDistance;
-    function move(particle, moveOptions, moveSpeed, maxSpeed, moveDrift, delta) {
-        applyPath(particle, delta);
-        const gravityOptions = particle.gravity, gravityFactor = gravityOptions?.enable && gravityOptions.inverse ? -1 : 1;
+    async function move(particle, moveOptions, moveSpeed, maxSpeed, moveDrift, delta) {
+        await applyPath(particle, delta);
+        const gravityOptions = particle.gravity, gravityFactor = gravityOptions?.enable && gravityOptions.inverse ? -identity : identity;
         if (moveDrift && moveSpeed) {
-            particle.velocity.x += (moveDrift * delta.factor) / (60 * moveSpeed);
+            particle.velocity.x += (moveDrift * delta.factor) / (moveSpeedFactor * moveSpeed);
         }
         if (gravityOptions?.enable && moveSpeed) {
-            particle.velocity.y += (gravityFactor * (gravityOptions.acceleration * delta.factor)) / (60 * moveSpeed);
+            particle.velocity.y +=
+                (gravityFactor * (gravityOptions.acceleration * delta.factor)) / (moveSpeedFactor * moveSpeed);
         }
         const decay = particle.moveDecay;
         particle.velocity.multTo(decay);
         const velocity = particle.velocity.mult(moveSpeed);
         if (gravityOptions?.enable &&
-            maxSpeed > 0 &&
-            ((!gravityOptions.inverse && velocity.y >= 0 && velocity.y >= maxSpeed) ||
-                (gravityOptions.inverse && velocity.y <= 0 && velocity.y <= -maxSpeed))) {
+            maxSpeed > minVelocity &&
+            ((!gravityOptions.inverse && velocity.y >= minVelocity && velocity.y >= maxSpeed) ||
+                (gravityOptions.inverse && velocity.y <= minVelocity && velocity.y <= -maxSpeed))) {
             velocity.y = gravityFactor * maxSpeed;
             if (moveSpeed) {
                 particle.velocity.y = velocity.y / moveSpeed;
             }
         }
-        const zIndexOptions = particle.options.zIndex, zVelocityFactor = (1 - particle.zIndexFactor) ** zIndexOptions.velocityRate;
+        const zIndexOptions = particle.options.zIndex, zVelocityFactor = (identity - particle.zIndexFactor) ** zIndexOptions.velocityRate;
         velocity.multTo(zVelocityFactor);
         const { position } = particle;
         position.addTo(velocity);
@@ -82,19 +87,19 @@
         particle.position.x = particle.spin.center.x + particle.spin.radius * updateFunc.x(particle.spin.angle);
         particle.position.y = particle.spin.center.y + particle.spin.radius * updateFunc.y(particle.spin.angle);
         particle.spin.radius += particle.spin.acceleration;
-        const maxCanvasSize = Math.max(container.canvas.size.width, container.canvas.size.height), halfMaxSize = maxCanvasSize * 0.5;
+        const maxCanvasSize = Math.max(container.canvas.size.width, container.canvas.size.height), halfMaxSize = maxCanvasSize * half;
         if (particle.spin.radius > halfMaxSize) {
             particle.spin.radius = halfMaxSize;
-            particle.spin.acceleration *= -1;
+            particle.spin.acceleration *= -identity;
         }
-        else if (particle.spin.radius < 0) {
-            particle.spin.radius = 0;
-            particle.spin.acceleration *= -1;
+        else if (particle.spin.radius < minSpinRadius) {
+            particle.spin.radius = minSpinRadius;
+            particle.spin.acceleration *= -identity;
         }
-        particle.spin.angle += moveSpeed * 0.01 * (1 - particle.spin.radius / maxCanvasSize);
+        particle.spin.angle += moveSpeed * spinFactor * (identity - particle.spin.radius / maxCanvasSize);
     }
     exports.spin = spin;
-    function applyPath(particle, delta) {
+    async function applyPath(particle, delta) {
         const particlesOptions = particle.options, pathOptions = particlesOptions.move.path, pathEnabled = pathOptions.enable;
         if (!pathEnabled) {
             return;
@@ -103,19 +108,39 @@
             particle.lastPathTime += delta.value;
             return;
         }
-        const path = particle.pathGenerator?.generate(particle, delta);
+        const path = await particle.pathGenerator?.generate(particle, delta);
         if (path) {
             particle.velocity.addTo(path);
         }
         if (pathOptions.clamp) {
-            particle.velocity.x = (0, engine_1.clamp)(particle.velocity.x, -1, 1);
-            particle.velocity.y = (0, engine_1.clamp)(particle.velocity.y, -1, 1);
+            particle.velocity.x = (0, engine_1.clamp)(particle.velocity.x, -identity, identity);
+            particle.velocity.y = (0, engine_1.clamp)(particle.velocity.y, -identity, identity);
         }
         particle.lastPathTime -= particle.pathDelay;
     }
     exports.applyPath = applyPath;
     function getProximitySpeedFactor(particle) {
-        return particle.slow.inRange ? particle.slow.factor : 1;
+        return particle.slow.inRange ? particle.slow.factor : identity;
     }
     exports.getProximitySpeedFactor = getProximitySpeedFactor;
+    function initSpin(particle) {
+        const container = particle.container, options = particle.options, spinOptions = options.move.spin;
+        if (!spinOptions.enable) {
+            return;
+        }
+        const spinPos = spinOptions.position ?? { x: 50, y: 50 }, spinFactor = 0.01, spinCenter = {
+            x: spinPos.x * spinFactor * container.canvas.size.width,
+            y: spinPos.y * spinFactor * container.canvas.size.height,
+        }, pos = particle.getPosition(), distance = (0, engine_1.getDistance)(pos, spinCenter), spinAcceleration = (0, engine_1.getRangeValue)(spinOptions.acceleration);
+        particle.retina.spinAcceleration = spinAcceleration * container.retina.pixelRatio;
+        const minVelocity = 0;
+        particle.spin = {
+            center: spinCenter,
+            direction: particle.velocity.x >= minVelocity ? "clockwise" : "counter-clockwise",
+            angle: particle.velocity.angle,
+            radius: distance,
+            acceleration: particle.retina.spinAcceleration,
+        };
+    }
+    exports.initSpin = initSpin;
 });

package/umd/index.js

@@ -1,18 +1,44 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./BaseMover.js"], factory);
+        define(["require", "exports"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.loadBaseMover = void 0;
-    const BaseMover_js_1 = require("./BaseMover.js");
     async function loadBaseMover(engine, refresh = true) {
-        await engine.addMover("base", () => new BaseMover_js_1.BaseMover(), refresh);
+        await engine.addMover("base", async () => {
+            const { BaseMover } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./BaseMover.js"))) : new Promise((resolve_1, reject_1) => { require(["./BaseMover.js"], resolve_1, reject_1); }).then(__importStar));
+            return new BaseMover();
+        }, refresh);
     }
     exports.loadBaseMover = loadBaseMover;
 });