@tsparticles/engine 3.0.0-alpha.0

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveTrailFill = void 0;
+const OptionsColor_1 = require("../../OptionsColor");
+class MoveTrailFill {
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.color !== undefined) {
+            this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+        }
+        if (data.image !== undefined) {
+            this.image = data.image;
+        }
+    }
+}
+exports.MoveTrailFill = MoveTrailFill;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutModes = void 0;
+class OutModes {
+    constructor() {
+        this.default = "out";
+    }
+    load(data) {
+        var _a, _b, _c, _d;
+        if (!data) {
+            return;
+        }
+        if (data.default !== undefined) {
+            this.default = data.default;
+        }
+        this.bottom = (_a = data.bottom) !== null && _a !== void 0 ? _a : data.default;
+        this.left = (_b = data.left) !== null && _b !== void 0 ? _b : data.default;
+        this.right = (_c = data.right) !== null && _c !== void 0 ? _c : data.default;
+        this.top = (_d = data.top) !== null && _d !== void 0 ? _d : data.default;
+    }
+}
+exports.OutModes = OutModes;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MovePath = void 0;
+const ValueWithRandom_1 = require("../../../ValueWithRandom");
+const Utils_1 = require("../../../../../Utils/Utils");
+class MovePath {
+    constructor() {
+        this.clamp = true;
+        this.delay = new ValueWithRandom_1.ValueWithRandom();
+        this.enable = false;
+        this.options = {};
+    }
+    load(data) {
+        if (!data) {
+            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.MovePath = MovePath;

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/Number/ParticlesDensity.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticlesDensity = void 0;
+class ParticlesDensity {
+    constructor() {
+        this.enable = false;
+        this.width = 1920;
+        this.height = 1080;
+    }
+    get area() {
+        return this.width;
+    }
+    set area(value) {
+        this.width = value;
+    }
+    get factor() {
+        return this.height;
+    }
+    set factor(value) {
+        this.height = value;
+    }
+    get value_area() {
+        return this.area;
+    }
+    set value_area(value) {
+        this.area = value;
+    }
+    load(data) {
+        var _a, _b, _c;
+        if (!data) {
+            return;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        const width = (_b = (_a = data.width) !== null && _a !== void 0 ? _a : data.area) !== null && _b !== void 0 ? _b : data.value_area;
+        if (width !== undefined) {
+            this.width = width;
+        }
+        const height = (_c = data.height) !== null && _c !== void 0 ? _c : data.factor;
+        if (height !== undefined) {
+            this.height = height;
+        }
+    }
+}
+exports.ParticlesDensity = ParticlesDensity;

package/cjs/Options/Classes/Particles/Number/ParticlesNumber.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticlesNumber = void 0;
+const ParticlesDensity_1 = require("./ParticlesDensity");
+class ParticlesNumber {
+    constructor() {
+        this.density = new ParticlesDensity_1.ParticlesDensity();
+        this.limit = 0;
+        this.value = 100;
+    }
+    get max() {
+        return this.limit;
+    }
+    set max(value) {
+        this.limit = value;
+    }
+    load(data) {
+        var _a;
+        if (!data) {
+            return;
+        }
+        this.density.load(data.density);
+        const limit = (_a = data.limit) !== null && _a !== void 0 ? _a : data.max;
+        if (limit !== undefined) {
+            this.limit = limit;
+        }
+        if (data.value !== undefined) {
+            this.value = data.value;
+        }
+    }
+}
+exports.ParticlesNumber = ParticlesNumber;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Opacity = void 0;
+const OpacityAnimation_1 = require("./OpacityAnimation");
+const ValueWithRandom_1 = require("../../ValueWithRandom");
+class Opacity extends ValueWithRandom_1.RangedAnimationValueWithRandom {
+    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;
+    }
+}
+exports.Opacity = Opacity;

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

@@ -0,0 +1,30 @@
+"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/cjs/Options/Classes/Particles/ParticlesOptions.js

@@ -0,0 +1,96 @@
+"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/cjs/Options/Classes/Particles/Shadow.js

@@ -0,0 +1,38 @@
+"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/cjs/Options/Classes/Particles/Shape/Shape.js

@@ -0,0 +1,29 @@
+"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/cjs/Options/Classes/Particles/Size/Size.js

@@ -0,0 +1,20 @@
+"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/cjs/Options/Classes/Particles/Size/SizeAnimation.js

@@ -0,0 +1,30 @@
+"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/cjs/Options/Classes/Particles/Stroke.js

@@ -0,0 +1,25 @@
+"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/cjs/Options/Classes/Particles/ZIndex/ZIndex.js

@@ -0,0 +1,28 @@
+"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/cjs/Options/Classes/Random.js

@@ -0,0 +1,21 @@
+"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/cjs/Options/Classes/Responsive.js

@@ -0,0 +1,31 @@
+"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/cjs/Options/Classes/Theme/Theme.js

@@ -0,0 +1,24 @@
+"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/cjs/Options/Classes/Theme/ThemeDefault.js

@@ -0,0 +1,25 @@
+"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/cjs/Options/Classes/ValueWithRandom.js

@@ -0,0 +1,68 @@
+"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/cjs/Options/Interfaces/Background/IBackground.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });