tsparticles 1.40.1 → 1.41.2

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

@@ -0,0 +1,45 @@
+(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", "../../OptionsColor", "./RollLight", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Roll = void 0;
+    const OptionsColor_1 = require("../../OptionsColor");
+    const RollLight_1 = require("./RollLight");
+    const Utils_1 = require("../../../../Utils");
+    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, Utils_1.setRangeValue)(data.speed);
+            }
+        }
+    }
+    exports.Roll = Roll;
+});

package/umd/Options/Classes/Particles/Roll/RollLight.d.ts

@@ -0,0 +1,9 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRollLight } from "../../../Interfaces/Particles/Roll/IRollLight";
+import type { RecursivePartial } from "../../../../Types";
+export declare class RollLight implements IRollLight, IOptionLoader<IRollLight> {
+    enable: boolean;
+    value: number;
+    constructor();
+    load(data?: RecursivePartial<IRollLight>): void;
+}

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

@@ -0,0 +1,31 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RollLight = void 0;
+    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 = data.value;
+            }
+        }
+    }
+    exports.RollLight = RollLight;
+});

package/umd/Options/Classes/Particles/Rotate/Rotate.d.ts

@@ -0,0 +1,13 @@
+import { RotateDirection, RotateDirectionAlt } from "../../../../Enums";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRotate } from "../../../Interfaces/Particles/Rotate/IRotate";
+import type { RecursivePartial } from "../../../../Types";
+import { RotateAnimation } from "./RotateAnimation";
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class Rotate extends ValueWithRandom implements IRotate, IOptionLoader<IRotate> {
+    animation: RotateAnimation;
+    direction: RotateDirection | keyof typeof RotateDirection | RotateDirectionAlt;
+    path: boolean;
+    constructor();
+    load(data?: RecursivePartial<IRotate>): void;
+}

package/umd/Options/Classes/Particles/Rotate/Rotate.js

@@ -0,0 +1,38 @@
+(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", "./RotateAnimation", "../../ValueWithRandom"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Rotate = void 0;
+    const RotateAnimation_1 = require("./RotateAnimation");
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    class Rotate extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.animation = new RotateAnimation_1.RotateAnimation();
+            this.direction = "clockwise";
+            this.path = false;
+            this.value = 0;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            super.load(data);
+            if (data.direction !== undefined) {
+                this.direction = data.direction;
+            }
+            this.animation.load(data.animation);
+            if (data.path !== undefined) {
+                this.path = data.path;
+            }
+        }
+    }
+    exports.Rotate = Rotate;
+});

package/umd/Options/Classes/Particles/Rotate/RotateAnimation.d.ts

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRotateAnimation } from "../../../Interfaces/Particles/Rotate/IRotateAnimation";
+import type { RecursivePartial } from "../../../../Types";
+export declare class RotateAnimation implements IRotateAnimation, IOptionLoader<IRotateAnimation> {
+    enable: boolean;
+    speed: number;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IRotateAnimation>): void;
+}

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

@@ -0,0 +1,35 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RotateAnimation = void 0;
+    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 = data.speed;
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+        }
+    }
+    exports.RotateAnimation = RotateAnimation;
+});

package/umd/Options/Classes/Particles/Shadow.d.ts

@@ -0,0 +1,13 @@
+import type { ICoordinates } from "../../../Core";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { IShadow } from "../../Interfaces/Particles/IShadow";
+import { OptionsColor } from "../OptionsColor";
+import type { RecursivePartial } from "../../../Types";
+export declare class Shadow implements IShadow, IOptionLoader<IShadow> {
+    blur: number;
+    color: OptionsColor;
+    enable: boolean;
+    offset: ICoordinates;
+    constructor();
+    load(data?: RecursivePartial<IShadow>): void;
+}

package/umd/Options/Classes/Particles/Shadow.js

@@ -0,0 +1,48 @@
+(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", "../OptionsColor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Shadow = void 0;
+    const OptionsColor_1 = require("../OptionsColor");
+    class Shadow {
+        constructor() {
+            this.blur = 0;
+            this.color = new OptionsColor_1.OptionsColor();
+            this.enable = false;
+            this.offset = {
+                x: 0,
+                y: 0,
+            };
+            this.color.value = "#000000";
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.blur !== undefined) {
+                this.blur = data.blur;
+            }
+            this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.offset === undefined) {
+                return;
+            }
+            if (data.offset.x !== undefined) {
+                this.offset.x = data.offset.x;
+            }
+            if (data.offset.y !== undefined) {
+                this.offset.y = data.offset.y;
+            }
+        }
+    }
+    exports.Shadow = Shadow;
+});

package/umd/Options/Classes/Particles/Shape/Shape.d.ts

@@ -0,0 +1,27 @@
+import type { RecursivePartial, ShapeData, SingleOrMultiple } from "../../../../Types";
+import type { ICharacterShape } from "../../../Interfaces/Particles/Shape/ICharacterShape";
+import type { IImageShape } from "../../../Interfaces/Particles/Shape/IImageShape";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IPolygonShape } from "../../../Interfaces/Particles/Shape/IPolygonShape";
+import type { IShape } from "../../../Interfaces/Particles/Shape/IShape";
+import { ShapeType } from "../../../../Enums";
+import { Stroke } from "../Stroke";
+export declare class Shape implements IShape, IOptionLoader<IShape> {
+    get image(): SingleOrMultiple<IImageShape>;
+    set image(value: SingleOrMultiple<IImageShape>);
+    get custom(): ShapeData;
+    set custom(value: ShapeData);
+    get images(): SingleOrMultiple<IImageShape>;
+    set images(value: SingleOrMultiple<IImageShape>);
+    get stroke(): SingleOrMultiple<Stroke>;
+    set stroke(_value: SingleOrMultiple<Stroke>);
+    get character(): SingleOrMultiple<ICharacterShape>;
+    set character(value: SingleOrMultiple<ICharacterShape>);
+    get polygon(): SingleOrMultiple<IPolygonShape>;
+    set polygon(value: SingleOrMultiple<IPolygonShape>);
+    type: SingleOrMultiple<ShapeType | keyof typeof ShapeType | string>;
+    options: ShapeData;
+    constructor();
+    load(data?: RecursivePartial<IShape>): void;
+    private loadShape;
+}

package/umd/Options/Classes/Particles/Shape/Shape.js

@@ -0,0 +1,113 @@
+(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.Shape = void 0;
+    const Utils_1 = require("../../../../Utils");
+    class Shape {
+        constructor() {
+            this.options = {};
+            this.type = "circle";
+        }
+        get image() {
+            var _a;
+            return ((_a = this.options["image"]) !== null && _a !== void 0 ? _a : this.options["images"]);
+        }
+        set image(value) {
+            this.options["image"] = value;
+            this.options["images"] = value;
+        }
+        get custom() {
+            return this.options;
+        }
+        set custom(value) {
+            this.options = value;
+        }
+        get images() {
+            return this.image;
+        }
+        set images(value) {
+            this.image = value;
+        }
+        get stroke() {
+            return [];
+        }
+        set stroke(_value) {
+        }
+        get character() {
+            var _a;
+            return ((_a = this.options["character"]) !== null && _a !== void 0 ? _a : this.options["char"]);
+        }
+        set character(value) {
+            this.options["character"] = value;
+            this.options["char"] = value;
+        }
+        get polygon() {
+            var _a;
+            return ((_a = this.options["polygon"]) !== null && _a !== void 0 ? _a : this.options["star"]);
+        }
+        set polygon(value) {
+            this.options["polygon"] = value;
+            this.options["star"] = value;
+        }
+        load(data) {
+            var _a, _b, _c;
+            if (data === undefined) {
+                return;
+            }
+            const options = (_a = data.options) !== null && _a !== void 0 ? _a : data.custom;
+            if (options !== undefined) {
+                for (const shape in options) {
+                    const item = options[shape];
+                    if (item !== undefined) {
+                        this.options[shape] = (0, Utils_1.deepExtend)((_b = this.options[shape]) !== null && _b !== void 0 ? _b : {}, item);
+                    }
+                }
+            }
+            this.loadShape(data.character, "character", "char", true);
+            this.loadShape(data.polygon, "polygon", "star", false);
+            this.loadShape((_c = data.image) !== null && _c !== void 0 ? _c : data.images, "image", "images", true);
+            if (data.type !== undefined) {
+                this.type = data.type;
+            }
+        }
+        loadShape(item, mainKey, altKey, altOverride) {
+            var _a, _b, _c, _d;
+            if (item === undefined) {
+                return;
+            }
+            if (item instanceof Array) {
+                if (!(this.options[mainKey] instanceof Array)) {
+                    this.options[mainKey] = [];
+                    if (!this.options[altKey] || altOverride) {
+                        this.options[altKey] = [];
+                    }
+                }
+                this.options[mainKey] = (0, Utils_1.deepExtend)((_a = this.options[mainKey]) !== null && _a !== void 0 ? _a : [], item);
+                if (!this.options[altKey] || altOverride) {
+                    this.options[altKey] = (0, Utils_1.deepExtend)((_b = this.options[altKey]) !== null && _b !== void 0 ? _b : [], item);
+                }
+            }
+            else {
+                if (this.options[mainKey] instanceof Array) {
+                    this.options[mainKey] = {};
+                    if (!this.options[altKey] || altOverride) {
+                        this.options[altKey] = {};
+                    }
+                }
+                this.options[mainKey] = (0, Utils_1.deepExtend)((_c = this.options[mainKey]) !== null && _c !== void 0 ? _c : {}, item);
+                if (!this.options[altKey] || altOverride) {
+                    this.options[altKey] = (0, Utils_1.deepExtend)((_d = this.options[altKey]) !== null && _d !== void 0 ? _d : {}, item);
+                }
+            }
+        }
+    }
+    exports.Shape = Shape;
+});

package/umd/Options/Classes/Particles/Size/Size.d.ts

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ISize } from "../../../Interfaces/Particles/Size/ISize";
+import type { RecursivePartial } from "../../../../Types";
+import { SizeAnimation } from "./SizeAnimation";
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class Size extends ValueWithRandom implements ISize, IOptionLoader<ISize> {
+    get anim(): SizeAnimation;
+    set anim(value: SizeAnimation);
+    animation: SizeAnimation;
+    constructor();
+    load(data?: RecursivePartial<ISize>): void;
+}

package/umd/Options/Classes/Particles/Size/Size.js

@@ -0,0 +1,43 @@
+(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", "./SizeAnimation", "../../ValueWithRandom", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Size = void 0;
+    const SizeAnimation_1 = require("./SizeAnimation");
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    const Utils_1 = require("../../../../Utils");
+    class Size extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.animation = new SizeAnimation_1.SizeAnimation();
+            this.random.minimumValue = 1;
+            this.value = 3;
+        }
+        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, Utils_1.setRangeValue)(this.value, this.animation.enable ? this.animation.minimumValue : undefined);
+            }
+        }
+    }
+    exports.Size = Size;
+});

package/umd/Options/Classes/Particles/Size/SizeAnimation.d.ts

@@ -0,0 +1,14 @@
+import { DestroyType, StartValueType } from "../../../../Enums";
+import { AnimationOptions } from "../../AnimationOptions";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ISizeAnimation } from "../../../Interfaces/Particles/Size/ISizeAnimation";
+import type { RecursivePartial } from "../../../../Types";
+export declare class SizeAnimation extends AnimationOptions implements ISizeAnimation, IOptionLoader<ISizeAnimation> {
+    get size_min(): number | undefined;
+    set size_min(value: number | undefined);
+    destroy: DestroyType | keyof typeof DestroyType;
+    minimumValue?: number;
+    startValue: StartValueType | keyof typeof StartValueType;
+    constructor();
+    load(data?: RecursivePartial<ISizeAnimation>): void;
+}

package/umd/Options/Classes/Particles/Size/SizeAnimation.js

@@ -0,0 +1,54 @@
+(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", "../../AnimationOptions"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SizeAnimation = void 0;
+    const AnimationOptions_1 = require("../../AnimationOptions");
+    class SizeAnimation extends AnimationOptions_1.AnimationOptions {
+        constructor() {
+            super();
+            this.destroy = "none";
+            this.enable = false;
+            this.speed = 5;
+            this.startValue = "random";
+            this.sync = false;
+        }
+        get size_min() {
+            return this.minimumValue;
+        }
+        set size_min(value) {
+            this.minimumValue = value;
+        }
+        load(data) {
+            var _a;
+            if (data === undefined) {
+                return;
+            }
+            super.load(data);
+            if (data.destroy !== undefined) {
+                this.destroy = data.destroy;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            this.minimumValue = (_a = data.minimumValue) !== null && _a !== void 0 ? _a : data.size_min;
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+            if (data.startValue !== undefined) {
+                this.startValue = data.startValue;
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+        }
+    }
+    exports.SizeAnimation = SizeAnimation;
+});

package/umd/Options/Classes/Particles/Stroke.d.ts

@@ -0,0 +1,11 @@
+import { AnimatableColor } from "../AnimatableColor";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { IStroke } from "../../Interfaces/Particles/IStroke";
+import type { RecursivePartial } from "../../../Types";
+export declare class Stroke implements IStroke, IOptionLoader<IStroke> {
+    color?: AnimatableColor;
+    width: number;
+    opacity?: number;
+    constructor();
+    load(data?: RecursivePartial<IStroke>): void;
+}

package/umd/Options/Classes/Particles/Stroke.js

@@ -0,0 +1,34 @@
+(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", "../AnimatableColor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Stroke = void 0;
+    const AnimatableColor_1 = require("../AnimatableColor");
+    class Stroke {
+        constructor() {
+            this.width = 0;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.color !== undefined) {
+                this.color = AnimatableColor_1.AnimatableColor.create(this.color, data.color);
+            }
+            if (data.width !== undefined) {
+                this.width = data.width;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = data.opacity;
+            }
+        }
+    }
+    exports.Stroke = Stroke;
+});

package/umd/Options/Classes/Particles/Tilt/Tilt.d.ts

@@ -0,0 +1,13 @@
+import { TiltDirection, TiltDirectionAlt } from "../../../../Enums";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ITilt } from "../../../Interfaces/Particles/Tilt/ITilt";
+import type { RecursivePartial } from "../../../../Types";
+import { TiltAnimation } from "./TiltAnimation";
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class Tilt extends ValueWithRandom implements ITilt, IOptionLoader<ITilt> {
+    animation: TiltAnimation;
+    direction: TiltDirection | keyof typeof TiltDirection | TiltDirectionAlt;
+    enable: boolean;
+    constructor();
+    load(data?: RecursivePartial<ITilt>): void;
+}

package/umd/Options/Classes/Particles/Tilt/Tilt.js

@@ -0,0 +1,38 @@
+(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", "./TiltAnimation", "../../ValueWithRandom"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Tilt = void 0;
+    const TiltAnimation_1 = require("./TiltAnimation");
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    class Tilt extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.animation = new TiltAnimation_1.TiltAnimation();
+            this.direction = "clockwise";
+            this.enable = false;
+            this.value = 0;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            super.load(data);
+            this.animation.load(data.animation);
+            if (data.direction !== undefined) {
+                this.direction = data.direction;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+        }
+    }
+    exports.Tilt = Tilt;
+});

package/umd/Options/Classes/Particles/Tilt/TiltAnimation.d.ts

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ITiltAnimation } from "../../../Interfaces/Particles/Tilt/ITiltAnimation";
+import type { RecursivePartial } from "../../../../Types";
+export declare class TiltAnimation implements ITiltAnimation, IOptionLoader<ITiltAnimation> {
+    enable: boolean;
+    speed: number;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<ITiltAnimation>): void;
+}