tsparticles 1.40.2 → 1.41.0

package/umd/Updaters/Size/SizeUpdater.d.ts

@@ -0,0 +1,6 @@
+import type { IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class SizeUpdater implements IParticleUpdater {
+    init(): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}

package/umd/Updaters/Size/SizeUpdater.js

@@ -0,0 +1,86 @@
+(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", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SizeUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function checkDestroy(particle, value, minValue, maxValue) {
+        switch (particle.options.size.animation.destroy) {
+            case "max":
+                if (value >= maxValue) {
+                    particle.destroy();
+                }
+                break;
+            case "min":
+                if (value <= minValue) {
+                    particle.destroy();
+                }
+                break;
+        }
+    }
+    function updateSize(particle, delta) {
+        var _a, _b, _c, _d;
+        const sizeVelocity = ((_a = particle.size.velocity) !== null && _a !== void 0 ? _a : 0) * delta.factor;
+        const minValue = particle.size.min;
+        const maxValue = particle.size.max;
+        if (!(!particle.destroyed &&
+            particle.size.enable &&
+            (((_b = particle.size.loops) !== null && _b !== void 0 ? _b : 0) <= 0 || ((_c = particle.size.loops) !== null && _c !== void 0 ? _c : 0) < ((_d = particle.size.maxLoops) !== null && _d !== void 0 ? _d : 0)))) {
+            return;
+        }
+        switch (particle.size.status) {
+            case 0:
+                if (particle.size.value >= maxValue) {
+                    particle.size.status = 1;
+                    if (!particle.size.loops) {
+                        particle.size.loops = 0;
+                    }
+                    particle.size.loops++;
+                }
+                else {
+                    particle.size.value += sizeVelocity;
+                }
+                break;
+            case 1:
+                if (particle.size.value <= minValue) {
+                    particle.size.status = 0;
+                    if (!particle.size.loops) {
+                        particle.size.loops = 0;
+                    }
+                    particle.size.loops++;
+                }
+                else {
+                    particle.size.value -= sizeVelocity;
+                }
+        }
+        checkDestroy(particle, particle.size.value, minValue, maxValue);
+        if (!particle.destroyed) {
+            particle.size.value = (0, Utils_1.clamp)(particle.size.value, minValue, maxValue);
+        }
+    }
+    class SizeUpdater {
+        init() {
+        }
+        isEnabled(particle) {
+            var _a, _b, _c;
+            return (!particle.destroyed &&
+                !particle.spawning &&
+                particle.size.enable &&
+                (((_a = particle.size.loops) !== null && _a !== void 0 ? _a : 0) <= 0 || ((_b = particle.size.loops) !== null && _b !== void 0 ? _b : 0) < ((_c = particle.size.maxLoops) !== null && _c !== void 0 ? _c : 0)));
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateSize(particle, delta);
+        }
+    }
+    exports.SizeUpdater = SizeUpdater;
+});

package/umd/Updaters/Size/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadSizeUpdater(engine: Engine): Promise<void>;

package/umd/Updaters/Size/index.js

@@ -0,0 +1,18 @@
+(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", "./SizeUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadSizeUpdater = void 0;
+    const SizeUpdater_1 = require("./SizeUpdater");
+    async function loadSizeUpdater(engine) {
+        await engine.addParticleUpdater("size", () => new SizeUpdater_1.SizeUpdater());
+    }
+    exports.loadSizeUpdater = loadSizeUpdater;
+});

package/umd/Updaters/StrokeColor/StrokeColorUpdater.d.ts

@@ -0,0 +1,8 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class StrokeColorUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: Container);
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}

package/umd/Updaters/StrokeColor/StrokeColorUpdater.js

@@ -0,0 +1,94 @@
+(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", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StrokeColorUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function updateColorValue(delta, value, valueAnimation, max, decrease) {
+        var _a;
+        const colorValue = value;
+        if (!colorValue || !colorValue.enable) {
+            return;
+        }
+        const offset = (0, Utils_1.randomInRange)(valueAnimation.offset);
+        const velocity = ((_a = value.velocity) !== null && _a !== void 0 ? _a : 0) * delta.factor + offset * 3.6;
+        if (!decrease || colorValue.status === 0) {
+            colorValue.value += velocity;
+            if (decrease && colorValue.value > max) {
+                colorValue.status = 1;
+                colorValue.value -= colorValue.value % max;
+            }
+        }
+        else {
+            colorValue.value -= velocity;
+            if (colorValue.value < 0) {
+                colorValue.status = 0;
+                colorValue.value += colorValue.value;
+            }
+        }
+        if (colorValue.value > max) {
+            colorValue.value %= max;
+        }
+    }
+    function updateStrokeColor(particle, delta) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        if (!((_a = particle.stroke) === null || _a === void 0 ? void 0 : _a.color)) {
+            return;
+        }
+        const animationOptions = particle.stroke.color.animation;
+        const h = (_c = (_b = particle.strokeColor) === null || _b === void 0 ? void 0 : _b.h) !== null && _c !== void 0 ? _c : (_d = particle.color) === null || _d === void 0 ? void 0 : _d.h;
+        if (h) {
+            updateColorValue(delta, h, animationOptions.h, 360, false);
+        }
+        const s = (_f = (_e = particle.strokeColor) === null || _e === void 0 ? void 0 : _e.s) !== null && _f !== void 0 ? _f : (_g = particle.color) === null || _g === void 0 ? void 0 : _g.s;
+        if (s) {
+            updateColorValue(delta, s, animationOptions.s, 100, true);
+        }
+        const l = (_j = (_h = particle.strokeColor) === null || _h === void 0 ? void 0 : _h.l) !== null && _j !== void 0 ? _j : (_k = particle.color) === null || _k === void 0 ? void 0 : _k.l;
+        if (l) {
+            updateColorValue(delta, l, animationOptions.l, 100, true);
+        }
+    }
+    class StrokeColorUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init(particle) {
+            var _a, _b;
+            const container = this.container;
+            particle.stroke =
+                particle.options.stroke instanceof Array
+                    ? (0, Utils_1.itemFromArray)(particle.options.stroke, particle.id, particle.options.reduceDuplicates)
+                    : particle.options.stroke;
+            particle.strokeWidth = particle.stroke.width * container.retina.pixelRatio;
+            const strokeHslColor = (_a = (0, Utils_1.colorToHsl)(particle.stroke.color)) !== null && _a !== void 0 ? _a : particle.getFillColor();
+            if (strokeHslColor) {
+                particle.strokeColor = (0, Utils_1.getHslAnimationFromHsl)(strokeHslColor, (_b = particle.stroke.color) === null || _b === void 0 ? void 0 : _b.animation, container.retina.reduceFactor);
+            }
+        }
+        isEnabled(particle) {
+            var _a, _b, _c, _d;
+            const color = (_a = particle.stroke) === null || _a === void 0 ? void 0 : _a.color;
+            return (!particle.destroyed &&
+                !particle.spawning &&
+                !!color &&
+                ((((_b = particle.strokeColor) === null || _b === void 0 ? void 0 : _b.h.value) !== undefined && color.animation.h.enable) ||
+                    (((_c = particle.strokeColor) === null || _c === void 0 ? void 0 : _c.s.value) !== undefined && color.animation.s.enable) ||
+                    (((_d = particle.strokeColor) === null || _d === void 0 ? void 0 : _d.l.value) !== undefined && color.animation.l.enable)));
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateStrokeColor(particle, delta);
+        }
+    }
+    exports.StrokeColorUpdater = StrokeColorUpdater;
+});

package/umd/Updaters/StrokeColor/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadStrokeColorUpdater(engine: Engine): Promise<void>;

package/umd/Updaters/StrokeColor/index.js

@@ -0,0 +1,18 @@
+(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", "./StrokeColorUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadStrokeColorUpdater = void 0;
+    const StrokeColorUpdater_1 = require("./StrokeColorUpdater");
+    async function loadStrokeColorUpdater(engine) {
+        await engine.addParticleUpdater("strokeColor", (container) => new StrokeColorUpdater_1.StrokeColorUpdater(container));
+    }
+    exports.loadStrokeColorUpdater = loadStrokeColorUpdater;
+});

package/umd/Updaters/Tilt/TiltUpdater.d.ts

@@ -0,0 +1,8 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class TiltUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: Container);
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}

package/umd/Updaters/Tilt/TiltUpdater.js

@@ -0,0 +1,89 @@
+(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", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TiltUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function updateTilt(particle, delta) {
+        var _a;
+        if (!particle.tilt) {
+            return;
+        }
+        const tilt = particle.options.tilt;
+        const tiltAnimation = tilt.animation;
+        const speed = ((_a = particle.tilt.velocity) !== null && _a !== void 0 ? _a : 0) * delta.factor;
+        const max = 2 * Math.PI;
+        if (!tiltAnimation.enable) {
+            return;
+        }
+        switch (particle.tilt.status) {
+            case 0:
+                particle.tilt.value += speed;
+                if (particle.tilt.value > max) {
+                    particle.tilt.value -= max;
+                }
+                break;
+            case 1:
+            default:
+                particle.tilt.value -= speed;
+                if (particle.tilt.value < 0) {
+                    particle.tilt.value += max;
+                }
+                break;
+        }
+    }
+    class TiltUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init(particle) {
+            const tiltOptions = particle.options.tilt;
+            particle.tilt = {
+                enable: tiltOptions.enable,
+                value: ((0, Utils_1.getRangeValue)(tiltOptions.value) * Math.PI) / 180,
+                sinDirection: Math.random() >= 0.5 ? 1 : -1,
+                cosDirection: Math.random() >= 0.5 ? 1 : -1,
+            };
+            let tiltDirection = tiltOptions.direction;
+            if (tiltDirection === "random") {
+                const index = Math.floor(Math.random() * 2);
+                tiltDirection = index > 0 ? "counter-clockwise" : "clockwise";
+            }
+            switch (tiltDirection) {
+                case "counter-clockwise":
+                case "counterClockwise":
+                    particle.tilt.status = 1;
+                    break;
+                case "clockwise":
+                    particle.tilt.status = 0;
+                    break;
+            }
+            const tiltAnimation = particle.options.tilt.animation;
+            if (tiltAnimation.enable) {
+                particle.tilt.velocity = (tiltAnimation.speed / 360) * this.container.retina.reduceFactor;
+                if (!tiltAnimation.sync) {
+                    particle.tilt.velocity *= Math.random();
+                }
+            }
+        }
+        isEnabled(particle) {
+            const tilt = particle.options.tilt;
+            const tiltAnimation = tilt.animation;
+            return !particle.destroyed && !particle.spawning && tiltAnimation.enable;
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateTilt(particle, delta);
+        }
+    }
+    exports.TiltUpdater = TiltUpdater;
+});

package/umd/Updaters/Tilt/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadTiltUpdater(engine: Engine): Promise<void>;

package/umd/Updaters/Tilt/index.js

@@ -0,0 +1,18 @@
+(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", "./TiltUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadTiltUpdater = void 0;
+    const TiltUpdater_1 = require("./TiltUpdater");
+    async function loadTiltUpdater(engine) {
+        await engine.addParticleUpdater("tilt", (container) => new TiltUpdater_1.TiltUpdater(container));
+    }
+    exports.loadTiltUpdater = loadTiltUpdater;
+});

package/umd/Updaters/Wobble/WobbleUpdater.d.ts

@@ -0,0 +1,14 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
+declare type WobbleParticle = Particle & {
+    retina: {
+        wobbleDistance?: number;
+    };
+};
+export declare class WobbleUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: Container);
+    init(particle: WobbleParticle): void;
+    isEnabled(particle: WobbleParticle): boolean;
+    update(particle: WobbleParticle, delta: IDelta): void;
+}
+export {};

package/umd/Updaters/Wobble/WobbleUpdater.js

@@ -0,0 +1,61 @@
+(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", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WobbleUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function updateWobble(particle, delta) {
+        var _a;
+        const wobble = particle.options.wobble;
+        if (!wobble.enable || !particle.wobble) {
+            return;
+        }
+        const speed = particle.wobble.speed * delta.factor;
+        const distance = (((_a = particle.retina.wobbleDistance) !== null && _a !== void 0 ? _a : 0) * delta.factor) / (1000 / 60);
+        const max = 2 * Math.PI;
+        particle.wobble.angle += speed;
+        if (particle.wobble.angle > max) {
+            particle.wobble.angle -= max;
+        }
+        particle.position.x += distance * Math.cos(particle.wobble.angle);
+        particle.position.y += distance * Math.abs(Math.sin(particle.wobble.angle));
+    }
+    class WobbleUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init(particle) {
+            const wobbleOpt = particle.options.wobble;
+            if (wobbleOpt.enable) {
+                particle.wobble = {
+                    angle: Math.random() * Math.PI * 2,
+                    speed: (0, Utils_1.getRangeValue)(wobbleOpt.speed) / 360,
+                };
+            }
+            else {
+                particle.wobble = {
+                    angle: 0,
+                    speed: 0,
+                };
+            }
+            particle.retina.wobbleDistance = (0, Utils_1.getRangeValue)(wobbleOpt.distance) * this.container.retina.pixelRatio;
+        }
+        isEnabled(particle) {
+            return !particle.destroyed && !particle.spawning && particle.options.wobble.enable;
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateWobble(particle, delta);
+        }
+    }
+    exports.WobbleUpdater = WobbleUpdater;
+});

package/umd/Updaters/Wobble/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadWobbleUpdater(engine: Engine): Promise<void>;

package/umd/Updaters/Wobble/index.js

@@ -0,0 +1,18 @@
+(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", "./WobbleUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadWobbleUpdater = void 0;
+    const WobbleUpdater_1 = require("./WobbleUpdater");
+    async function loadWobbleUpdater(engine) {
+        await engine.addParticleUpdater("wobble", (container) => new WobbleUpdater_1.WobbleUpdater(container));
+    }
+    exports.loadWobbleUpdater = loadWobbleUpdater;
+});

package/umd/Utils/CanvasUtils.d.ts

@@ -0,0 +1,19 @@
+import { AlterType } from "../Enums";
+import type { Container, IContainerPlugin, ICoordinates, IDelta, IDimension, IHsl, IParticle, IParticleGradientAnimation, IRgb } from "../Core";
+import type { ILinksShadow } from "../Options/Interfaces/Particles/Links/ILinksShadow";
+import type { IShadow } from "../Options/Interfaces/Particles/IShadow";
+import type { Particle } from "../Core";
+export declare function paintBase(context: CanvasRenderingContext2D, dimension: IDimension, baseColor?: string): void;
+export declare function clear(context: CanvasRenderingContext2D, dimension: IDimension): void;
+export declare function drawLinkLine(context: CanvasRenderingContext2D, width: number, begin: ICoordinates, end: ICoordinates, maxDistance: number, canvasSize: IDimension, warp: boolean, backgroundMask: boolean, composite: string, colorLine: IRgb, opacity: number, shadow: ILinksShadow): void;
+export declare function drawLinkTriangle(context: CanvasRenderingContext2D, pos1: ICoordinates, pos2: ICoordinates, pos3: ICoordinates, backgroundMask: boolean, composite: string, colorTriangle: IRgb, opacityTriangle: number): void;
+export declare function drawConnectLine(context: CanvasRenderingContext2D, width: number, lineStyle: CanvasGradient, begin: ICoordinates, end: ICoordinates): void;
+export declare function gradient(context: CanvasRenderingContext2D, p1: IParticle, p2: IParticle, opacity: number): CanvasGradient | undefined;
+export declare function drawGrabLine(context: CanvasRenderingContext2D, width: number, begin: ICoordinates, end: ICoordinates, colorLine: IRgb, opacity: number): void;
+export declare function drawParticle(container: Container, context: CanvasRenderingContext2D, particle: IParticle, delta: IDelta, fillColorValue: string | undefined, strokeColorValue: string | undefined, backgroundMask: boolean, composite: string, radius: number, opacity: number, shadow: IShadow, gradient?: IParticleGradientAnimation): void;
+export declare function drawShape(container: Container, context: CanvasRenderingContext2D, particle: IParticle, radius: number, opacity: number, delta: IDelta): void;
+export declare function drawShapeAfterEffect(container: Container, context: CanvasRenderingContext2D, particle: IParticle, radius: number, opacity: number, delta: IDelta): void;
+export declare function drawPlugin(context: CanvasRenderingContext2D, plugin: IContainerPlugin, delta: IDelta): void;
+export declare function drawParticlePlugin(context: CanvasRenderingContext2D, plugin: IContainerPlugin, particle: Particle, delta: IDelta): void;
+export declare function drawEllipse(context: CanvasRenderingContext2D, particle: IParticle, fillColorValue: IHsl | undefined, radius: number, opacity: number, width: number, rotation: number, start: number, end: number): void;
+export declare function alterHsl(color: IHsl, type: AlterType, value: number): IHsl;