@tsparticles/engine 3.0.0-alpha.0

package/umd/Options/Classes/Particles/Opacity/OpacityAnimation.js

@@ -0,0 +1,40 @@
+(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.OpacityAnimation = void 0;
+    const AnimationOptions_1 = require("../../AnimationOptions");
+    class OpacityAnimation extends AnimationOptions_1.RangedAnimationOptions {
+        constructor() {
+            super();
+            this.destroy = "none";
+            this.speed = 2;
+        }
+        get opacity_min() {
+            return this.minimumValue;
+        }
+        set opacity_min(value) {
+            this.minimumValue = value;
+        }
+        load(data) {
+            if ((data === null || data === void 0 ? void 0 : data.opacity_min) !== undefined && data.minimumValue === undefined) {
+                data.minimumValue = data.opacity_min;
+            }
+            super.load(data);
+            if (!data) {
+                return;
+            }
+            if (data.destroy !== undefined) {
+                this.destroy = data.destroy;
+            }
+        }
+    }
+    exports.OpacityAnimation = OpacityAnimation;
+});

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

@@ -0,0 +1,106 @@
+(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/Utils", "../AnimatableColor", "./Collisions/Collisions", "./Move/Move", "./Opacity/Opacity", "./Bounce/ParticlesBounce", "./Number/ParticlesNumber", "./Shadow", "./Shape/Shape", "./Size/Size", "./Stroke", "./ZIndex/ZIndex"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ParticlesOptions = void 0;
+    const Utils_1 = require("../../../Utils/Utils");
+    const AnimatableColor_1 = require("../AnimatableColor");
+    const Collisions_1 = require("./Collisions/Collisions");
+    const Move_1 = require("./Move/Move");
+    const Opacity_1 = require("./Opacity/Opacity");
+    const ParticlesBounce_1 = require("./Bounce/ParticlesBounce");
+    const ParticlesNumber_1 = require("./Number/ParticlesNumber");
+    const Shadow_1 = require("./Shadow");
+    const Shape_1 = require("./Shape/Shape");
+    const Size_1 = require("./Size/Size");
+    const Stroke_1 = require("./Stroke");
+    const ZIndex_1 = require("./ZIndex/ZIndex");
+    class ParticlesOptions {
+        constructor(engine, container) {
+            this._engine = engine;
+            this._container = container;
+            this.bounce = new ParticlesBounce_1.ParticlesBounce();
+            this.collisions = new Collisions_1.Collisions();
+            this.color = new AnimatableColor_1.AnimatableColor();
+            this.color.value = "#fff";
+            this.groups = {};
+            this.move = new Move_1.Move();
+            this.number = new ParticlesNumber_1.ParticlesNumber();
+            this.opacity = new Opacity_1.Opacity();
+            this.reduceDuplicates = false;
+            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.zIndex = new ZIndex_1.ZIndex();
+        }
+        load(data) {
+            var _a, _b, _c, _d;
+            if (!data) {
+                return;
+            }
+            this.bounce.load(data.bounce);
+            this.color.load(AnimatableColor_1.AnimatableColor.create(this.color, data.color));
+            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)((_a = this.groups[group]) !== null && _a !== void 0 ? _a : {}, item);
+                    }
+                }
+            }
+            this.move.load(data.move);
+            this.number.load(data.number);
+            this.opacity.load(data.opacity);
+            if (data.reduceDuplicates !== undefined) {
+                this.reduceDuplicates = data.reduceDuplicates;
+            }
+            this.shape.load(data.shape);
+            this.size.load(data.size);
+            this.shadow.load(data.shadow);
+            this.zIndex.load(data.zIndex);
+            const collisions = (_c = (_b = data.move) === null || _b === void 0 ? void 0 : _b.collisions) !== null && _c !== void 0 ? _c : (_d = data.move) === null || _d === void 0 ? void 0 : _d.bounce;
+            if (collisions !== undefined) {
+                this.collisions.enable = collisions;
+            }
+            this.collisions.load(data.collisions);
+            if (data.interactivity !== undefined) {
+                this.interactivity = (0, Utils_1.deepExtend)({}, data.interactivity);
+            }
+            const stroke = data.stroke;
+            if (stroke) {
+                this.stroke = (0, Utils_1.executeOnSingleOrMultiple)(stroke, (t) => {
+                    const tmp = new Stroke_1.Stroke();
+                    tmp.load(t);
+                    return tmp;
+                });
+            }
+            if (this._container) {
+                const updaters = this._engine.plugins.updaters.get(this._container);
+                if (updaters) {
+                    for (const updater of updaters) {
+                        if (updater.loadOptions) {
+                            updater.loadOptions(this, data);
+                        }
+                    }
+                }
+                const interactors = this._engine.plugins.interactors.get(this._container);
+                if (interactors) {
+                    for (const interactor of interactors) {
+                        if (interactor.loadParticlesOptions) {
+                            interactor.loadParticlesOptions(this, data);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    exports.ParticlesOptions = ParticlesOptions;
+});

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 = "#000";
+        }
+        load(data) {
+            if (!data) {
+                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.js

@@ -0,0 +1,39 @@
+(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/Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Shape = void 0;
+    const Utils_1 = require("../../../../Utils/Utils");
+    class Shape {
+        constructor() {
+            this.options = {};
+            this.type = "circle";
+        }
+        load(data) {
+            var _a;
+            if (!data) {
+                return;
+            }
+            const options = data.options;
+            if (options !== undefined) {
+                for (const shape in options) {
+                    const item = options[shape];
+                    if (item) {
+                        this.options[shape] = (0, Utils_1.deepExtend)((_a = this.options[shape]) !== null && _a !== void 0 ? _a : {}, item);
+                    }
+                }
+            }
+            if (data.type !== undefined) {
+                this.type = data.type;
+            }
+        }
+    }
+    exports.Shape = Shape;
+});

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

@@ -0,0 +1,30 @@
+(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", "../../ValueWithRandom", "./SizeAnimation"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Size = void 0;
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    const SizeAnimation_1 = require("./SizeAnimation");
+    class Size extends ValueWithRandom_1.RangedAnimationValueWithRandom {
+        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;
+        }
+    }
+    exports.Size = Size;
+});

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

@@ -0,0 +1,40 @@
+(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.RangedAnimationOptions {
+        constructor() {
+            super();
+            this.destroy = "none";
+            this.speed = 5;
+        }
+        get size_min() {
+            return this.minimumValue;
+        }
+        set size_min(value) {
+            this.minimumValue = value;
+        }
+        load(data) {
+            if ((data === null || data === void 0 ? void 0 : data.size_min) !== undefined && data.minimumValue === undefined) {
+                data.minimumValue = data.size_min;
+            }
+            super.load(data);
+            if (!data) {
+                return;
+            }
+            if (data.destroy !== undefined) {
+                this.destroy = data.destroy;
+            }
+        }
+    }
+    exports.SizeAnimation = SizeAnimation;
+});

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

package/umd/Options/Classes/Particles/ZIndex/ZIndex.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", "../../ValueWithRandom"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ZIndex = void 0;
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    class ZIndex extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.opacityRate = 1;
+            this.sizeRate = 1;
+            this.velocityRate = 1;
+        }
+        load(data) {
+            super.load(data);
+            if (!data) {
+                return;
+            }
+            if (data.opacityRate !== undefined) {
+                this.opacityRate = data.opacityRate;
+            }
+            if (data.sizeRate !== undefined) {
+                this.sizeRate = data.sizeRate;
+            }
+            if (data.velocityRate !== undefined) {
+                this.velocityRate = data.velocityRate;
+            }
+        }
+    }
+    exports.ZIndex = ZIndex;
+});

package/umd/Options/Classes/Random.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.Random = void 0;
+    class Random {
+        constructor() {
+            this.enable = false;
+            this.minimumValue = 0;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.minimumValue !== undefined) {
+                this.minimumValue = data.minimumValue;
+            }
+        }
+    }
+    exports.Random = Random;
+});

package/umd/Options/Classes/Responsive.js

@@ -0,0 +1,41 @@
+(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/Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Responsive = void 0;
+    const Utils_1 = require("../../Utils/Utils");
+    class Responsive {
+        constructor() {
+            this.maxWidth = Infinity;
+            this.options = {};
+            this.mode = "canvas";
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.maxWidth !== undefined) {
+                this.maxWidth = data.maxWidth;
+            }
+            if (data.mode !== undefined) {
+                if (data.mode === "screen") {
+                    this.mode = "screen";
+                }
+                else {
+                    this.mode = "canvas";
+                }
+            }
+            if (data.options !== undefined) {
+                this.options = (0, Utils_1.deepExtend)({}, data.options);
+            }
+        }
+    }
+    exports.Responsive = Responsive;
+});

package/umd/Options/Classes/Theme/Theme.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", "./ThemeDefault", "../../../Utils/Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Theme = void 0;
+    const ThemeDefault_1 = require("./ThemeDefault");
+    const Utils_1 = require("../../../Utils/Utils");
+    class Theme {
+        constructor() {
+            this.name = "";
+            this.default = new ThemeDefault_1.ThemeDefault();
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.name !== undefined) {
+                this.name = data.name;
+            }
+            this.default.load(data.default);
+            if (data.options !== undefined) {
+                this.options = (0, Utils_1.deepExtend)({}, data.options);
+            }
+        }
+    }
+    exports.Theme = Theme;
+});

package/umd/Options/Classes/Theme/ThemeDefault.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.ThemeDefault = void 0;
+    class ThemeDefault {
+        constructor() {
+            this.auto = false;
+            this.mode = "any";
+            this.value = false;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.auto !== undefined) {
+                this.auto = data.auto;
+            }
+            if (data.mode !== undefined) {
+                this.mode = data.mode;
+            }
+            if (data.value !== undefined) {
+                this.value = data.value;
+            }
+        }
+    }
+    exports.ThemeDefault = ThemeDefault;
+});

package/umd/Options/Classes/ValueWithRandom.js

@@ -0,0 +1,78 @@
+(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", "./Random", "./AnimationOptions", "../../Utils/NumberUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RangedAnimationValueWithRandom = exports.AnimationValueWithRandom = exports.ValueWithRandom = void 0;
+    const AnimationOptions_1 = require("./AnimationOptions");
+    const Random_1 = require("./Random");
+    const AnimationOptions_2 = require("./AnimationOptions");
+    const NumberUtils_1 = require("../../Utils/NumberUtils");
+    class ValueWithRandom {
+        constructor() {
+            this.random = new Random_1.Random();
+            this.value = 0;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (typeof data.random === "boolean") {
+                this.random.enable = data.random;
+            }
+            else {
+                this.random.load(data.random);
+            }
+            if (data.value !== undefined) {
+                this.value = (0, NumberUtils_1.setRangeValue)(data.value, this.random.enable ? this.random.minimumValue : undefined);
+            }
+        }
+    }
+    exports.ValueWithRandom = ValueWithRandom;
+    class AnimationValueWithRandom extends ValueWithRandom {
+        constructor() {
+            super();
+            this.animation = new AnimationOptions_1.AnimationOptions();
+        }
+        get anim() {
+            return this.animation;
+        }
+        set anim(value) {
+            this.animation = value;
+        }
+        load(data) {
+            var _a;
+            super.load(data);
+            if (!data) {
+                return;
+            }
+            const animation = (_a = data.animation) !== null && _a !== void 0 ? _a : data.anim;
+            if (animation !== undefined) {
+                this.animation.load(animation);
+            }
+        }
+    }
+    exports.AnimationValueWithRandom = AnimationValueWithRandom;
+    class RangedAnimationValueWithRandom extends AnimationValueWithRandom {
+        constructor() {
+            super();
+            this.animation = new AnimationOptions_2.RangedAnimationOptions();
+        }
+        load(data) {
+            super.load(data);
+            if (!data) {
+                return;
+            }
+            if (data.animation !== undefined) {
+                this.value = (0, NumberUtils_1.setRangeValue)(this.value, this.animation.enable ? this.animation.minimumValue : undefined);
+            }
+        }
+    }
+    exports.RangedAnimationValueWithRandom = RangedAnimationValueWithRandom;
+});

package/umd/Options/Interfaces/Background/IBackground.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/BackgroundMask/IBackgroundMask.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/BackgroundMask/IBackgroundMaskCover.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/FullScreen/IFullScreen.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/IAnimatable.js

@@ -0,0 +1,12 @@
+(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 });
+});