tsparticles 1.42.3 → 1.43.1

package/cjs/Options/Classes/Particles/Move/Move.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Move = void 0;
+const Attract_1 = require("./Attract");
+const MoveAngle_1 = require("./MoveAngle");
+const MoveGravity_1 = require("./MoveGravity");
+const OutModes_1 = require("./OutModes");
+const Path_1 = require("./Path/Path");
+const Spin_1 = require("./Spin");
+const Trail_1 = require("./Trail");
+const Utils_1 = require("../../../../Utils/Utils");
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class Move {
+    constructor() {
+        this.angle = new MoveAngle_1.MoveAngle();
+        this.attract = new Attract_1.Attract();
+        this.decay = 0;
+        this.distance = {};
+        this.direction = "none";
+        this.drift = 0;
+        this.enable = false;
+        this.gravity = new MoveGravity_1.MoveGravity();
+        this.path = new Path_1.Path();
+        this.outModes = new OutModes_1.OutModes();
+        this.random = false;
+        this.size = false;
+        this.speed = 2;
+        this.spin = new Spin_1.Spin();
+        this.straight = false;
+        this.trail = new Trail_1.Trail();
+        this.vibrate = false;
+        this.warp = false;
+    }
+    get collisions() {
+        return false;
+    }
+    set collisions(value) {
+    }
+    get bounce() {
+        return this.collisions;
+    }
+    set bounce(value) {
+        this.collisions = value;
+    }
+    get out_mode() {
+        return this.outMode;
+    }
+    set out_mode(value) {
+        this.outMode = value;
+    }
+    get outMode() {
+        return this.outModes.default;
+    }
+    set outMode(value) {
+        this.outModes.default = value;
+    }
+    get noise() {
+        return this.path;
+    }
+    set noise(value) {
+        this.path = value;
+    }
+    load(data) {
+        var _a, _b, _c;
+        if (data === undefined) {
+            return;
+        }
+        if (data.angle !== undefined) {
+            if (typeof data.angle === "number") {
+                this.angle.value = data.angle;
+            }
+            else {
+                this.angle.load(data.angle);
+            }
+        }
+        this.attract.load(data.attract);
+        if (data.decay !== undefined) {
+            this.decay = data.decay;
+        }
+        if (data.direction !== undefined) {
+            this.direction = data.direction;
+        }
+        if (data.distance !== undefined) {
+            this.distance =
+                typeof data.distance === "number"
+                    ? {
+                        horizontal: data.distance,
+                        vertical: data.distance,
+                    }
+                    : (0, Utils_1.deepExtend)({}, data.distance);
+        }
+        if (data.drift !== undefined) {
+            this.drift = (0, NumberUtils_1.setRangeValue)(data.drift);
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        this.gravity.load(data.gravity);
+        const outMode = (_a = data.outMode) !== null && _a !== void 0 ? _a : data.out_mode;
+        if (data.outModes !== undefined || outMode !== undefined) {
+            if (typeof data.outModes === "string" || (data.outModes === undefined && outMode !== undefined)) {
+                this.outModes.load({
+                    default: (_b = data.outModes) !== null && _b !== void 0 ? _b : outMode,
+                });
+            }
+            else {
+                this.outModes.load(data.outModes);
+            }
+        }
+        this.path.load((_c = data.path) !== null && _c !== void 0 ? _c : data.noise);
+        if (data.random !== undefined) {
+            this.random = data.random;
+        }
+        if (data.size !== undefined) {
+            this.size = data.size;
+        }
+        if (data.speed !== undefined) {
+            this.speed = (0, NumberUtils_1.setRangeValue)(data.speed);
+        }
+        this.spin.load(data.spin);
+        if (data.straight !== undefined) {
+            this.straight = data.straight;
+        }
+        this.trail.load(data.trail);
+        if (data.vibrate !== undefined) {
+            this.vibrate = data.vibrate;
+        }
+        if (data.warp !== undefined) {
+            this.warp = data.warp;
+        }
+    }
+}
+exports.Move = Move;

package/cjs/Options/Classes/Particles/Move/MoveAngle.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveAngle = void 0;
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class MoveAngle {
+    constructor() {
+        this.offset = 0;
+        this.value = 90;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.offset !== undefined) {
+            this.offset = (0, NumberUtils_1.setRangeValue)(data.offset);
+        }
+        if (data.value !== undefined) {
+            this.value = (0, NumberUtils_1.setRangeValue)(data.value);
+        }
+    }
+}
+exports.MoveAngle = MoveAngle;

package/cjs/Options/Classes/Particles/Move/MoveGravity.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveGravity = void 0;
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class MoveGravity {
+    constructor() {
+        this.acceleration = 9.81;
+        this.enable = false;
+        this.inverse = false;
+        this.maxSpeed = 50;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.acceleration !== undefined) {
+            this.acceleration = (0, NumberUtils_1.setRangeValue)(data.acceleration);
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.inverse !== undefined) {
+            this.inverse = data.inverse;
+        }
+        if (data.maxSpeed !== undefined) {
+            this.maxSpeed = (0, NumberUtils_1.setRangeValue)(data.maxSpeed);
+        }
+    }
+}
+exports.MoveGravity = MoveGravity;

package/cjs/Options/Classes/Particles/Move/Path/Path.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Path = void 0;
+const PathDelay_1 = require("./PathDelay");
+const Utils_1 = require("../../../../../Utils/Utils");
+class Path {
+    constructor() {
+        this.clamp = true;
+        this.delay = new PathDelay_1.PathDelay();
+        this.enable = false;
+        this.options = {};
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.clamp !== undefined) {
+            this.clamp = data.clamp;
+        }
+        this.delay.load(data.delay);
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        this.generator = data.generator;
+        if (data.options) {
+            this.options = (0, Utils_1.deepExtend)(this.options, data.options);
+        }
+    }
+}
+exports.Path = Path;

package/cjs/Options/Classes/Particles/Move/Spin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spin = void 0;
+const Utils_1 = require("../../../../Utils/Utils");
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class Spin {
+    constructor() {
+        this.acceleration = 0;
+        this.enable = false;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.acceleration !== undefined) {
+            this.acceleration = (0, NumberUtils_1.setRangeValue)(data.acceleration);
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        this.position = data.position ? (0, Utils_1.deepExtend)({}, data.position) : undefined;
+    }
+}
+exports.Spin = Spin;

package/cjs/Options/Classes/Particles/Opacity/Opacity.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Opacity = void 0;
+const OpacityAnimation_1 = require("./OpacityAnimation");
+const ValueWithRandom_1 = require("../../ValueWithRandom");
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class Opacity extends ValueWithRandom_1.ValueWithRandom {
+    constructor() {
+        super();
+        this.animation = new OpacityAnimation_1.OpacityAnimation();
+        this.random.minimumValue = 0.1;
+        this.value = 1;
+    }
+    get anim() {
+        return this.animation;
+    }
+    set anim(value) {
+        this.animation = value;
+    }
+    load(data) {
+        var _a;
+        if (!data) {
+            return;
+        }
+        super.load(data);
+        const animation = (_a = data.animation) !== null && _a !== void 0 ? _a : data.anim;
+        if (animation !== undefined) {
+            this.animation.load(animation);
+            this.value = (0, NumberUtils_1.setRangeValue)(this.value, this.animation.enable ? this.animation.minimumValue : undefined);
+        }
+    }
+}
+exports.Opacity = Opacity;

package/cjs/Options/Classes/Particles/Orbit/Orbit.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orbit = void 0;
+const AnimationOptions_1 = require("../../AnimationOptions");
+const OptionsColor_1 = require("../../OptionsColor");
+const OrbitRotation_1 = require("./OrbitRotation");
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class Orbit {
+    constructor() {
+        this.animation = new AnimationOptions_1.AnimationOptions();
+        this.enable = false;
+        this.opacity = 1;
+        this.rotation = new OrbitRotation_1.OrbitRotation();
+        this.width = 1;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        this.animation.load(data.animation);
+        this.rotation.load(data.rotation);
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.opacity !== undefined) {
+            this.opacity = (0, NumberUtils_1.setRangeValue)(data.opacity);
+        }
+        if (data.width !== undefined) {
+            this.width = (0, NumberUtils_1.setRangeValue)(data.width);
+        }
+        if (data.radius !== undefined) {
+            this.radius = (0, NumberUtils_1.setRangeValue)(data.radius);
+        }
+        if (data.color !== undefined) {
+            this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+        }
+    }
+}
+exports.Orbit = Orbit;

package/cjs/Options/Classes/Particles/ParticlesOptions.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticlesOptions = void 0;
+const AnimatableColor_1 = require("../AnimatableColor");
+const AnimatableGradient_1 = require("../AnimatableGradient");
+const Bounce_1 = require("./Bounce/Bounce");
+const Collisions_1 = require("./Collisions/Collisions");
+const Destroy_1 = require("./Destroy/Destroy");
+const Life_1 = require("./Life/Life");
+const Links_1 = require("./Links/Links");
+const Move_1 = require("./Move/Move");
+const Opacity_1 = require("./Opacity/Opacity");
+const Orbit_1 = require("./Orbit/Orbit");
+const ParticlesNumber_1 = require("./Number/ParticlesNumber");
+const Repulse_1 = require("./Repulse/Repulse");
+const Roll_1 = require("./Roll/Roll");
+const Rotate_1 = require("./Rotate/Rotate");
+const Shadow_1 = require("./Shadow");
+const Shape_1 = require("./Shape/Shape");
+const Size_1 = require("./Size/Size");
+const Stroke_1 = require("./Stroke");
+const Tilt_1 = require("./Tilt/Tilt");
+const Twinkle_1 = require("./Twinkle/Twinkle");
+const Wobble_1 = require("./Wobble/Wobble");
+const ZIndex_1 = require("./ZIndex/ZIndex");
+const Utils_1 = require("../../../Utils/Utils");
+class ParticlesOptions {
+    constructor() {
+        this.bounce = new Bounce_1.Bounce();
+        this.collisions = new Collisions_1.Collisions();
+        this.color = new AnimatableColor_1.AnimatableColor();
+        this.destroy = new Destroy_1.Destroy();
+        this.gradient = [];
+        this.groups = {};
+        this.life = new Life_1.Life();
+        this.links = new Links_1.Links();
+        this.move = new Move_1.Move();
+        this.number = new ParticlesNumber_1.ParticlesNumber();
+        this.opacity = new Opacity_1.Opacity();
+        this.orbit = new Orbit_1.Orbit();
+        this.reduceDuplicates = false;
+        this.repulse = new Repulse_1.Repulse();
+        this.roll = new Roll_1.Roll();
+        this.rotate = new Rotate_1.Rotate();
+        this.shadow = new Shadow_1.Shadow();
+        this.shape = new Shape_1.Shape();
+        this.size = new Size_1.Size();
+        this.stroke = new Stroke_1.Stroke();
+        this.tilt = new Tilt_1.Tilt();
+        this.twinkle = new Twinkle_1.Twinkle();
+        this.wobble = new Wobble_1.Wobble();
+        this.zIndex = new ZIndex_1.ZIndex();
+    }
+    get line_linked() {
+        return this.links;
+    }
+    set line_linked(value) {
+        this.links = value;
+    }
+    get lineLinked() {
+        return this.links;
+    }
+    set lineLinked(value) {
+        this.links = value;
+    }
+    load(data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (data === undefined) {
+            return;
+        }
+        this.bounce.load(data.bounce);
+        this.color.load(AnimatableColor_1.AnimatableColor.create(this.color, data.color));
+        this.destroy.load(data.destroy);
+        this.life.load(data.life);
+        const links = (_b = (_a = data.links) !== null && _a !== void 0 ? _a : data.lineLinked) !== null && _b !== void 0 ? _b : data.line_linked;
+        if (links !== undefined) {
+            this.links.load(links);
+        }
+        if (data.groups !== undefined) {
+            for (const group in data.groups) {
+                const item = data.groups[group];
+                if (item !== undefined) {
+                    this.groups[group] = (0, Utils_1.deepExtend)((_c = this.groups[group]) !== null && _c !== void 0 ? _c : {}, item);
+                }
+            }
+        }
+        this.move.load(data.move);
+        this.number.load(data.number);
+        this.opacity.load(data.opacity);
+        this.orbit.load(data.orbit);
+        if (data.reduceDuplicates !== undefined) {
+            this.reduceDuplicates = data.reduceDuplicates;
+        }
+        this.repulse.load(data.repulse);
+        this.roll.load(data.roll);
+        this.rotate.load(data.rotate);
+        this.shape.load(data.shape);
+        this.size.load(data.size);
+        this.shadow.load(data.shadow);
+        this.tilt.load(data.tilt);
+        this.twinkle.load(data.twinkle);
+        this.wobble.load(data.wobble);
+        this.zIndex.load(data.zIndex);
+        const collisions = (_e = (_d = data.move) === null || _d === void 0 ? void 0 : _d.collisions) !== null && _e !== void 0 ? _e : (_f = data.move) === null || _f === void 0 ? void 0 : _f.bounce;
+        if (collisions !== undefined) {
+            this.collisions.enable = collisions;
+        }
+        this.collisions.load(data.collisions);
+        const strokeToLoad = (_g = data.stroke) !== null && _g !== void 0 ? _g : (_h = data.shape) === null || _h === void 0 ? void 0 : _h.stroke;
+        if (strokeToLoad) {
+            if (strokeToLoad instanceof Array) {
+                this.stroke = strokeToLoad.map((s) => {
+                    const tmp = new Stroke_1.Stroke();
+                    tmp.load(s);
+                    return tmp;
+                });
+            }
+            else {
+                if (this.stroke instanceof Array) {
+                    this.stroke = new Stroke_1.Stroke();
+                }
+                this.stroke.load(strokeToLoad);
+            }
+        }
+        const gradientToLoad = data.gradient;
+        if (gradientToLoad) {
+            if (gradientToLoad instanceof Array) {
+                this.gradient = gradientToLoad.map((s) => {
+                    const tmp = new AnimatableGradient_1.AnimatableGradient();
+                    tmp.load(s);
+                    return tmp;
+                });
+            }
+            else {
+                if (this.gradient instanceof Array) {
+                    this.gradient = new AnimatableGradient_1.AnimatableGradient();
+                }
+                this.gradient.load(gradientToLoad);
+            }
+        }
+    }
+}
+exports.ParticlesOptions = ParticlesOptions;

package/cjs/Options/Classes/Particles/Repulse/Repulse.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repulse = void 0;
+const ValueWithRandom_1 = require("../../ValueWithRandom");
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class Repulse extends ValueWithRandom_1.ValueWithRandom {
+    constructor() {
+        super();
+        this.enabled = false;
+        this.distance = 1;
+        this.duration = 1;
+        this.factor = 1;
+        this.speed = 1;
+    }
+    load(data) {
+        super.load(data);
+        if (!data) {
+            return;
+        }
+        if (data.enabled !== undefined) {
+            this.enabled = data.enabled;
+        }
+        if (data.distance !== undefined) {
+            this.distance = (0, NumberUtils_1.setRangeValue)(data.distance);
+        }
+        if (data.duration !== undefined) {
+            this.duration = (0, NumberUtils_1.setRangeValue)(data.duration);
+        }
+        if (data.factor !== undefined) {
+            this.factor = (0, NumberUtils_1.setRangeValue)(data.factor);
+        }
+        if (data.speed !== undefined) {
+            this.speed = (0, NumberUtils_1.setRangeValue)(data.speed);
+        }
+    }
+}
+exports.Repulse = Repulse;

package/cjs/Options/Classes/Particles/Roll/Roll.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Roll = void 0;
+const OptionsColor_1 = require("../../OptionsColor");
+const RollLight_1 = require("./RollLight");
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class Roll {
+    constructor() {
+        this.darken = new RollLight_1.RollLight();
+        this.enable = false;
+        this.enlighten = new RollLight_1.RollLight();
+        this.mode = "vertical";
+        this.speed = 25;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.backColor !== undefined) {
+            this.backColor = OptionsColor_1.OptionsColor.create(this.backColor, data.backColor);
+        }
+        this.darken.load(data.darken);
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        this.enlighten.load(data.enlighten);
+        if (data.mode !== undefined) {
+            this.mode = data.mode;
+        }
+        if (data.speed !== undefined) {
+            this.speed = (0, NumberUtils_1.setRangeValue)(data.speed);
+        }
+    }
+}
+exports.Roll = Roll;

package/cjs/Options/Classes/Particles/Roll/RollLight.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RollLight = void 0;
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class RollLight {
+    constructor() {
+        this.enable = false;
+        this.value = 0;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.value !== undefined) {
+            this.value = (0, NumberUtils_1.setRangeValue)(data.value);
+        }
+    }
+}
+exports.RollLight = RollLight;

package/cjs/Options/Classes/Particles/Rotate/RotateAnimation.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotateAnimation = void 0;
+const NumberUtils_1 = require("../../../../Utils/NumberUtils");
+class RotateAnimation {
+    constructor() {
+        this.enable = false;
+        this.speed = 0;
+        this.sync = false;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.speed !== undefined) {
+            this.speed = (0, NumberUtils_1.setRangeValue)(data.speed);
+        }
+        if (data.sync !== undefined) {
+            this.sync = data.sync;
+        }
+    }
+}
+exports.RotateAnimation = RotateAnimation;