tsparticles 1.42.2 → 1.43.0

package/browser/Core/Utils/Plugins.js

@@ -9,26 +9,50 @@ var _Plugins_engine;
  * @category Utils
  */
 export class Plugins {
+    /**
+     * The constructor of the plugin manager
+     * @param engine the parent engine
+     */
     constructor(engine) {
+        /**
+         * The engine used for registering plugins
+         * @private
+         */
         _Plugins_engine.set(this, void 0);
         __classPrivateFieldSet(this, _Plugins_engine, engine, "f");
         this.plugins = [];
         this.interactorsInitializers = new Map();
+        this.moversInitializers = new Map();
         this.updatersInitializers = new Map();
         this.interactors = new Map();
+        this.movers = new Map();
         this.updaters = new Map();
         this.presets = new Map();
         this.drawers = new Map();
         this.pathGenerators = new Map();
     }
+    /**
+     * Searches if the specified plugin exists and returns it
+     * @param plugin the plugin name
+     * @returns the plugin if found, or undefined
+     */
     getPlugin(plugin) {
         return this.plugins.find((t) => t.id === plugin);
     }
+    /**
+     * Adds a plugin to the plugin system, if the plugin already exists, is not added
+     * @param plugin the plugin to add
+     */
     addPlugin(plugin) {
         if (!this.getPlugin(plugin.id)) {
             this.plugins.push(plugin);
         }
     }
+    /**
+     * Gets all the available plugins, for the specified container
+     * @param container the container used to check which are the valid plugins
+     * @returns a map containing all enabled plugins, with the id as a key
+     */
     getAvailablePlugins(container) {
         const res = new Map();
         for (const plugin of this.plugins) {
@@ -39,38 +63,84 @@ export class Plugins {
         }
         return res;
     }
+    /**
+     * Load the given options for all the plugins
+     * @param options the actual options to set
+     * @param sourceOptions the source options to read
+     */
     loadOptions(options, sourceOptions) {
         for (const plugin of this.plugins) {
             plugin.loadOptions(options, sourceOptions);
         }
     }
+    /**
+     * Searches the preset with the given name
+     * @param preset the preset name to search
+     * @returns the preset if found, or undefined
+     */
     getPreset(preset) {
         return this.presets.get(preset);
     }
+    /**
+     * Adds a preset to the existing collection
+     * @param presetKey the preset name
+     * @param options the options to load with the preset name
+     * @param override if true, overwrites the existing preset
+     */
     addPreset(presetKey, options, override = false) {
         if (override || !this.getPreset(presetKey)) {
             this.presets.set(presetKey, options);
         }
     }
+    /**
+     * Searches the given shape drawer type with the given type name
+     * @param type the shape drawer type name
+     * @returns the shape drawer if found, or undefined
+     */
+    getShapeDrawer(type) {
+        return this.drawers.get(type);
+    }
+    /**
+     * Adds a shape drawer (additional particle shape) to the current collection
+     * @param type the shape drawer type (particle shape name)
+     * @param drawer the shape drawer
+     */
     addShapeDrawer(type, drawer) {
         if (!this.getShapeDrawer(type)) {
             this.drawers.set(type, drawer);
         }
     }
-    getShapeDrawer(type) {
-        return this.drawers.get(type);
-    }
+    /**
+     * This method returns all the supported shapes with this Plugins instance
+     * @returns all the supported shapes type name
+     */
     getSupportedShapes() {
         return this.drawers.keys();
     }
+    /**
+     * Searches the path generator with the given type name
+     * @param type the path generator type to search
+     * @returns the path generator if found, or undefined
+     */
     getPathGenerator(type) {
         return this.pathGenerators.get(type);
     }
+    /**
+     * Adds a path generator to the current collection
+     * @param type the type used as a key in the collection
+     * @param pathGenerator the path generator to add
+     */
     addPathGenerator(type, pathGenerator) {
         if (!this.getPathGenerator(type)) {
             this.pathGenerators.set(type, pathGenerator);
         }
     }
+    /**
+     * Returns all the container interaction managers
+     * @param container the container used to check which interaction managers are compatible
+     * @param force if true reloads the interaction managers collection for the given container
+     * @returns the array of interaction managers for the given container
+     */
     getInteractors(container, force = false) {
         let res = this.interactors.get(container);
         if (!res || force) {
@@ -79,9 +149,20 @@ export class Plugins {
         }
         return res;
     }
+    /**
+     * Adds an interaction manager to the current collection
+     * @param name the interaction manager name
+     * @param initInteractor the interaction manager initializer
+     */
     addInteractor(name, initInteractor) {
         this.interactorsInitializers.set(name, initInteractor);
     }
+    /**
+     * Returns all the container particle updaters
+     * @param container the container used to check which particle updaters are enabled
+     * @param force if true reloads the updater collection for the given container
+     * @returns the array of updaters for the given container
+     */
     getUpdaters(container, force = false) {
         let res = this.updaters.get(container);
         if (!res || force) {
@@ -90,8 +171,24 @@ export class Plugins {
         }
         return res;
     }
+    /**
+     * Adds a particle updater to the collection
+     * @param name the particle updater name used as a key
+     * @param initUpdater the particle updater initializer
+     */
     addParticleUpdater(name, initUpdater) {
         this.updatersInitializers.set(name, initUpdater);
     }
+    getMovers(container, force = false) {
+        let res = this.movers.get(container);
+        if (!res || force) {
+            res = [...this.moversInitializers.values()].map((t) => t(container));
+            this.movers.set(container, res);
+        }
+        return res;
+    }
+    addParticleMover(name, initMover) {
+        this.moversInitializers.set(name, initMover);
+    }
 }
 _Plugins_engine = new WeakMap();

package/browser/Core/Utils/Point.js

@@ -2,6 +2,11 @@
  * @category Utils
  */
 export class Point {
+    /**
+     * The point constructor, initializing its position
+     * @param position the point position
+     * @param particle the particle assigned to this point
+     */
     constructor(position, particle) {
         this.position = position;
         this.particle = particle;

package/browser/Core/Utils/QuadTree.js

@@ -1,29 +1,27 @@
 import { Circle } from "./Circle";
 import { CircleWarp } from "./CircleWarp";
 import { Rectangle } from "./Rectangle";
-import { getDistance } from "../../Utils";
+import { getDistance } from "../../Utils/NumberUtils";
 /**
  * @category Utils
  */
 export class QuadTree {
+    /**
+     * Initializes the instance with a rectangle and a capacity
+     * @param rectangle the instance rectangle area
+     * @param capacity the points capacity
+     */
     constructor(rectangle, capacity) {
         this.rectangle = rectangle;
         this.capacity = capacity;
         this.points = [];
         this.divided = false;
     }
-    subdivide() {
-        const x = this.rectangle.position.x;
-        const y = this.rectangle.position.y;
-        const w = this.rectangle.size.width;
-        const h = this.rectangle.size.height;
-        const capacity = this.capacity;
-        this.northEast = new QuadTree(new Rectangle(x, y, w / 2, h / 2), capacity);
-        this.northWest = new QuadTree(new Rectangle(x + w / 2, y, w / 2, h / 2), capacity);
-        this.southEast = new QuadTree(new Rectangle(x, y + h / 2, w / 2, h / 2), capacity);
-        this.southWest = new QuadTree(new Rectangle(x + w / 2, y + h / 2, w / 2, h / 2), capacity);
-        this.divided = true;
-    }
+    /**
+     * Inserts the given point in the instance, or to its subtrees
+     * @param point the point to insert
+     * @returns true if the point is added to the instance or one of its subtrees, false if it's not
+     */
     insert(point) {
         var _a, _b, _c, _d, _e;
         if (!this.rectangle.contains(point.position)) {
@@ -41,37 +39,70 @@ export class QuadTree {
             ((_c = this.southEast) === null || _c === void 0 ? void 0 : _c.insert(point)) ||
             ((_d = this.southWest) === null || _d === void 0 ? void 0 : _d.insert(point)))) !== null && _e !== void 0 ? _e : false);
     }
+    /**
+     * Queries the instance using a [[Circle]] object, with the given position and the given radius
+     * @param position the circle position
+     * @param radius the circle radius
+     * @returns the particles inside the given circle
+     */
     queryCircle(position, radius) {
         return this.query(new Circle(position.x, position.y, radius));
     }
+    /**
+     * Queries the instance using a [[CircleWarp]] object, with the given position and the given radius
+     * @param position the circle position
+     * @param radius the circle radius
+     * @param containerOrSize the container canvas size
+     * @returns the particles inside the given circle
+     */
     queryCircleWarp(position, radius, containerOrSize) {
-        const container = containerOrSize;
-        const size = containerOrSize;
+        const container = containerOrSize, size = containerOrSize;
         return this.query(new CircleWarp(position.x, position.y, radius, container.canvas !== undefined ? container.canvas.size : size));
     }
+    /**
+     * Queries the instance using a [[Rectangle]] object, with the given position and the given size
+     * @param position the rectangle position
+     * @param size the rectangle size
+     * @returns the particles inside the given rectangle
+     */
     queryRectangle(position, size) {
         return this.query(new Rectangle(position.x, position.y, size.width, size.height));
     }
+    /**
+     * Queries the instance using a [[Rectangle]] object, with the given position and the given size
+     * @param range the range to use for querying the tree
+     * @param found found particles array, output parameter
+     * @returns the particles inside the given range
+     */
     query(range, found) {
         var _a, _b, _c, _d;
         const res = found !== null && found !== void 0 ? found : [];
         if (!range.intersects(this.rectangle)) {
             return [];
         }
-        else {
-            for (const p of this.points) {
-                if (!range.contains(p.position) && getDistance(range.position, p.position) > p.particle.getRadius()) {
-                    continue;
-                }
-                res.push(p.particle);
-            }
-            if (this.divided) {
-                (_a = this.northEast) === null || _a === void 0 ? void 0 : _a.query(range, res);
-                (_b = this.northWest) === null || _b === void 0 ? void 0 : _b.query(range, res);
-                (_c = this.southEast) === null || _c === void 0 ? void 0 : _c.query(range, res);
-                (_d = this.southWest) === null || _d === void 0 ? void 0 : _d.query(range, res);
+        for (const p of this.points) {
+            if (!range.contains(p.position) && getDistance(range.position, p.position) > p.particle.getRadius()) {
+                continue;
             }
+            res.push(p.particle);
+        }
+        if (this.divided) {
+            (_a = this.northEast) === null || _a === void 0 ? void 0 : _a.query(range, res);
+            (_b = this.northWest) === null || _b === void 0 ? void 0 : _b.query(range, res);
+            (_c = this.southEast) === null || _c === void 0 ? void 0 : _c.query(range, res);
+            (_d = this.southWest) === null || _d === void 0 ? void 0 : _d.query(range, res);
         }
         return res;
     }
+    /**
+     * Creates the subtrees, making the instance a branch
+     */
+    subdivide() {
+        const x = this.rectangle.position.x, y = this.rectangle.position.y, w = this.rectangle.size.width, h = this.rectangle.size.height, capacity = this.capacity;
+        this.northEast = new QuadTree(new Rectangle(x, y, w / 2, h / 2), capacity);
+        this.northWest = new QuadTree(new Rectangle(x + w / 2, y, w / 2, h / 2), capacity);
+        this.southEast = new QuadTree(new Rectangle(x, y + h / 2, w / 2, h / 2), capacity);
+        this.southWest = new QuadTree(new Rectangle(x + w / 2, y + h / 2, w / 2, h / 2), capacity);
+        this.divided = true;
+    }
 }

package/browser/Core/Utils/Range.js

@@ -2,6 +2,12 @@
  * @category Utils
  */
 export class Range {
+    /**
+     * Range constructor, initializes the position
+     * @param x X coordinate of the position
+     * @param y Y coordinate of the position
+     * @protected
+     */
     constructor(x, y) {
         this.position = {
             x: x,

package/browser/Core/Utils/Rectangle.js

@@ -3,6 +3,13 @@ import { Range } from "./Range";
  * @category Utils
  */
 export class Rectangle extends Range {
+    /**
+     * The rectangle constructor, initializes position and size
+     * @param x X coordinate of the position
+     * @param y Y coordinate of the position
+     * @param width Rectangle width
+     * @param height Rectangle height
+     */
     constructor(x, y, width, height) {
         super(x, y);
         this.size = {
@@ -10,28 +17,29 @@ export class Rectangle extends Range {
             width: width,
         };
     }
+    /**
+     * Check if the given point is inside the rectangle
+     * @param point the point to check
+     * @returns true or false, checking if the given point is inside the rectangle
+     */
     contains(point) {
-        const w = this.size.width;
-        const h = this.size.height;
-        const pos = this.position;
+        const w = this.size.width, h = this.size.height, pos = this.position;
         return point.x >= pos.x && point.x <= pos.x + w && point.y >= pos.y && point.y <= pos.y + h;
     }
+    /**
+     * Check if another range intersects the rectangle
+     * @param range the range to check
+     * @returns true or false, checking if the range is intersecting with the rectangle
+     */
     intersects(range) {
-        const rect = range;
-        const circle = range;
-        const w = this.size.width;
-        const h = this.size.height;
-        const pos1 = this.position;
-        const pos2 = range.position;
+        const rect = range, circle = range, w = this.size.width, h = this.size.height, pos1 = this.position, pos2 = range.position;
         if (circle.radius !== undefined) {
             return circle.intersects(this);
         }
-        else if (rect.size !== undefined) {
-            const size2 = rect.size;
-            const w2 = size2.width;
-            const h2 = size2.height;
-            return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
+        if (!rect.size) {
+            return false;
         }
-        return false;
+        const size2 = rect.size, w2 = size2.width, h2 = size2.height;
+        return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
     }
 }

package/browser/Core/Utils/Vector.js

@@ -1,90 +1,197 @@
+/**
+ * @category Utils
+ */
 export class Vector {
-    constructor(x, y) {
-        let defX, defY;
-        if (y === undefined) {
-            if (typeof x === "number") {
-                throw new Error("tsParticles - Vector not initialized correctly");
-            }
-            const coords = x;
-            [defX, defY] = [coords.x, coords.y];
+    /**
+     * Vector constructor, creating an instance with the given coordinates
+     * @param xOrCoords X coordinate or the whole [[ICoordinates]] object
+     * @param y Y coordinate
+     * @protected
+     */
+    constructor(xOrCoords, y) {
+        if (typeof xOrCoords !== "number" && xOrCoords) {
+            this.x = xOrCoords.x;
+            this.y = xOrCoords.y;
+        }
+        else if (xOrCoords !== undefined && y !== undefined) {
+            this.x = xOrCoords;
+            this.y = y;
         }
         else {
-            [defX, defY] = [x, y];
+            throw new Error("tsParticles - Vector not initialized correctly");
         }
-        this.x = defX;
-        this.y = defY;
     }
+    /**
+     * Clones the given vector
+     * @param source the vector to clone
+     * @returns a new vector instance, created from the given one
+     */
     static clone(source) {
         return Vector.create(source.x, source.y);
     }
+    /**
+     * Creates a new vector instance
+     * @param x X coordinate
+     * @param y Y coordinate
+     * @returns the new vector created
+     */
     static create(x, y) {
         return new Vector(x, y);
     }
+    /**
+     * A new vector, with coordinates in the origin point
+     */
     static get origin() {
         return Vector.create(0, 0);
     }
+    /**
+     * Returns the current vector angle, based on x,y values
+     */
     get angle() {
         return Math.atan2(this.y, this.x);
     }
+    /**
+     * Sets the x,y values using an angle, length must be greater than 0
+     * @param angle the angle to set
+     */
     set angle(angle) {
         this.updateFromAngle(angle, this.length);
     }
+    /**
+     * Returns the current vector length, based on x,y values
+     */
     get length() {
-        return Math.sqrt(this.x ** 2 + this.y ** 2);
+        return Math.sqrt(this.getLengthSq());
     }
+    /**
+     * Sets the x,y values using the length
+     * @param length the length to set
+     */
     set length(length) {
         this.updateFromAngle(this.angle, length);
     }
+    /**
+     * Adds the current and the given vector together, without modifying them
+     * @param v the vector used for the sum operation
+     * @returns the sum vector
+     */
     add(v) {
         return Vector.create(this.x + v.x, this.y + v.y);
     }
+    /**
+     * Adds the given vector to the current one, modifying it
+     * @param v the vector to add to the current one
+     */
     addTo(v) {
         this.x += v.x;
         this.y += v.y;
     }
+    /**
+     * Subtracts the current and the given vector together, without modifying them
+     * @param v the vector used for the subtract operation
+     * @returns the subtracted vector
+     */
     sub(v) {
         return Vector.create(this.x - v.x, this.y - v.y);
     }
+    /**
+     * Subtracts the given vector from the current one, modifying it
+     * @param v the vector to subtract from the current one
+     */
     subFrom(v) {
         this.x -= v.x;
         this.y -= v.y;
     }
+    /**
+     * Multiplies the given scalar and the current vector together, without modifying it
+     * @param n the scalar value to multiply to the vector
+     * @returns the multiplied vector
+     */
     mult(n) {
         return Vector.create(this.x * n, this.y * n);
     }
+    /**
+     * Multiplies the given scalar to the current vector, modifying it
+     * @param n the scalar value to multiply to the vector
+     */
     multTo(n) {
         this.x *= n;
         this.y *= n;
     }
+    /**
+     * Divides the given scalar and the current vector together, without modifying it
+     * @param n the scalar value to divide from the current vector
+     */
     div(n) {
         return Vector.create(this.x / n, this.y / n);
     }
+    /**
+     * Divides the given scalar from the current vector, modifying it
+     * @param n the scalar value to divide from the current vector
+     */
     divTo(n) {
         this.x /= n;
         this.y /= n;
     }
+    /**
+     * Calculates the distance between the current vector and the given one
+     * @param v the vector used for calculating the distance from the current one
+     * @returns the distance between the vectors
+     */
     distanceTo(v) {
         return this.sub(v).length;
     }
+    /**
+     * Get the squared length value
+     * @returns the squared length value
+     */
     getLengthSq() {
         return this.x ** 2 + this.y ** 2;
     }
+    /**
+     * Get the distance squared between two vectors
+     * @param v the vector used for calculating the distance from the current one
+     * @returns the distance squared between the vectors
+     */
     distanceToSq(v) {
         return this.sub(v).getLengthSq();
     }
+    /**
+     * Returns the Manhattan distance between all vectors
+     * @param v the vector used for calculating the distance from the current one
+     * @returns the Manhattan distance between the vectors
+     */
     manhattanDistanceTo(v) {
         return Math.abs(v.x - this.x) + Math.abs(v.y - this.y);
     }
+    /**
+     * Copies the current vector, cloning it
+     * @returns the cloned current vector
+     */
     copy() {
         return Vector.clone(this);
     }
-    setTo(velocity) {
-        this.x = velocity.x;
-        this.y = velocity.y;
-    }
+    /**
+     * Set the vector to the specified velocity
+     * @param v the Vector used to set the current vector
+     */
+    setTo(v) {
+        this.x = v.x;
+        this.y = v.y;
+    }
+    /**
+     * Creates a new vector, rotating the current one, without modifying it
+     * @param angle the rotation angle
+     */
     rotate(angle) {
         return Vector.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle));
     }
+    /**
+     * Updates the current vector, using angle and length values, instead of x and y
+     * @param angle the new angle
+     * @param length the new length
+     * @private
+     */
     updateFromAngle(angle, length) {
         this.x = Math.cos(angle) * length;
         this.y = Math.sin(angle) * length;