tsparticles 1.40.2 → 1.41.0

package/umd/Plugins/Absorbers/Options/Classes/Absorber.js

@@ -0,0 +1,57 @@
+(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", "./AbsorberSize", "../../../../Options/Classes/OptionsColor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Absorber = void 0;
+    const AbsorberSize_1 = require("./AbsorberSize");
+    const OptionsColor_1 = require("../../../../Options/Classes/OptionsColor");
+    class Absorber {
+        constructor() {
+            this.color = new OptionsColor_1.OptionsColor();
+            this.color.value = "#000000";
+            this.draggable = false;
+            this.opacity = 1;
+            this.destroy = true;
+            this.orbits = false;
+            this.size = new AbsorberSize_1.AbsorberSize();
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.color !== undefined) {
+                this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+            }
+            if (data.draggable !== undefined) {
+                this.draggable = data.draggable;
+            }
+            this.name = data.name;
+            if (data.opacity !== undefined) {
+                this.opacity = data.opacity;
+            }
+            if (data.position !== undefined) {
+                this.position = {
+                    x: data.position.x,
+                    y: data.position.y,
+                };
+            }
+            if (data.size !== undefined) {
+                this.size.load(data.size);
+            }
+            if (data.destroy !== undefined) {
+                this.destroy = data.destroy;
+            }
+            if (data.orbits !== undefined) {
+                this.orbits = data.orbits;
+            }
+        }
+    }
+    exports.Absorber = Absorber;
+});

package/umd/Plugins/Absorbers/Options/Classes/AbsorberSize.d.ts

@@ -0,0 +1,11 @@
+import { AbsorberSizeLimit } from "./AbsorberSizeLimit";
+import type { IAbsorberSize } from "../Interfaces/IAbsorberSize";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+import { ValueWithRandom } from "../../../../Options/Classes/ValueWithRandom";
+export declare class AbsorberSize extends ValueWithRandom implements IAbsorberSize, IOptionLoader<IAbsorberSize> {
+    density: number;
+    limit: AbsorberSizeLimit;
+    constructor();
+    load(data?: RecursivePartial<IAbsorberSize>): void;
+}

package/umd/Plugins/Absorbers/Options/Classes/AbsorberSize.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", "./AbsorberSizeLimit", "../../../../Options/Classes/ValueWithRandom"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AbsorberSize = void 0;
+    const AbsorberSizeLimit_1 = require("./AbsorberSizeLimit");
+    const ValueWithRandom_1 = require("../../../../Options/Classes/ValueWithRandom");
+    class AbsorberSize extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.density = 5;
+            this.random.minimumValue = 1;
+            this.value = 50;
+            this.limit = new AbsorberSizeLimit_1.AbsorberSizeLimit();
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            super.load(data);
+            if (data.density !== undefined) {
+                this.density = data.density;
+            }
+            if (typeof data.limit === "number") {
+                this.limit.radius = data.limit;
+            }
+            else {
+                this.limit.load(data.limit);
+            }
+        }
+    }
+    exports.AbsorberSize = AbsorberSize;
+});

package/umd/Plugins/Absorbers/Options/Classes/AbsorberSizeLimit.d.ts

@@ -0,0 +1,9 @@
+import type { IAbsorberSizeLimit } from "../Interfaces/IAbsorberSizeLimit";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+export declare class AbsorberSizeLimit implements IAbsorberSizeLimit, IOptionLoader<IAbsorberSizeLimit> {
+    radius: number;
+    mass: number;
+    constructor();
+    load(data?: RecursivePartial<IAbsorberSizeLimit>): void;
+}

package/umd/Plugins/Absorbers/Options/Classes/AbsorberSizeLimit.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.AbsorberSizeLimit = void 0;
+    class AbsorberSizeLimit {
+        constructor() {
+            this.radius = 0;
+            this.mass = 0;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.mass !== undefined) {
+                this.mass = data.mass;
+            }
+            if (data.radius !== undefined) {
+                this.radius = data.radius;
+            }
+        }
+    }
+    exports.AbsorberSizeLimit = AbsorberSizeLimit;
+});

package/umd/Plugins/Absorbers/Options/Interfaces/IAbsorber.d.ts

@@ -0,0 +1,13 @@
+import type { IColor, ICoordinates } from "../../../../Core";
+import type { IAbsorberSize } from "./IAbsorberSize";
+import { RecursivePartial } from "../../../../Types";
+export interface IAbsorber {
+    color: IColor | string;
+    name?: string;
+    opacity: number;
+    position?: RecursivePartial<ICoordinates>;
+    size: IAbsorberSize;
+    draggable: boolean;
+    destroy: boolean;
+    orbits: boolean;
+}

package/umd/Plugins/Absorbers/Options/Interfaces/IAbsorber.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/Plugins/Absorbers/Options/Interfaces/IAbsorberOptions.d.ts

@@ -0,0 +1,12 @@
+import type { IAbsorber } from "./IAbsorber";
+import type { IInteractivity } from "../../../../Options/Interfaces/Interactivity/IInteractivity";
+import type { IModes } from "../../../../Options/Interfaces/Interactivity/Modes/IModes";
+import type { SingleOrMultiple } from "../../../../Types";
+export interface IAbsorberOptions {
+    absorbers: SingleOrMultiple<IAbsorber>;
+    interactivity: IInteractivity & {
+        modes: IModes & {
+            absorbers: SingleOrMultiple<IAbsorber>;
+        };
+    };
+}

package/umd/Plugins/Absorbers/Options/Interfaces/IAbsorberOptions.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/Plugins/Absorbers/Options/Interfaces/IAbsorberSize.d.ts

@@ -0,0 +1,6 @@
+import type { IAbsorberSizeLimit } from "./IAbsorberSizeLimit";
+import type { IValueWithRandom } from "../../../../Options/Interfaces/IValueWithRandom";
+export interface IAbsorberSize extends IValueWithRandom {
+    limit?: number | IAbsorberSizeLimit;
+    density: number;
+}

package/umd/Plugins/Absorbers/Options/Interfaces/IAbsorberSize.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/Plugins/Absorbers/Options/Interfaces/IAbsorberSizeLimit.d.ts

@@ -0,0 +1,4 @@
+export interface IAbsorberSizeLimit {
+    radius: number;
+    mass: number;
+}

package/umd/Plugins/Absorbers/Options/Interfaces/IAbsorberSizeLimit.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/Plugins/Absorbers/index.d.ts

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

package/umd/Plugins/Absorbers/index.js

@@ -0,0 +1,90 @@
+(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", "./Options/Classes/Absorber", "./Absorbers", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadAbsorbersPlugin = void 0;
+    const Absorber_1 = require("./Options/Classes/Absorber");
+    const Absorbers_1 = require("./Absorbers");
+    const Utils_1 = require("../../Utils");
+    class AbsorbersPlugin {
+        constructor() {
+            this.id = "absorbers";
+        }
+        getPlugin(container) {
+            return new Absorbers_1.Absorbers(container);
+        }
+        needsPlugin(options) {
+            var _a, _b, _c;
+            if (options === undefined) {
+                return false;
+            }
+            const absorbers = options.absorbers;
+            let loadAbsorbers = false;
+            if (absorbers instanceof Array) {
+                if (absorbers.length) {
+                    loadAbsorbers = true;
+                }
+            }
+            else if (absorbers !== undefined) {
+                loadAbsorbers = true;
+            }
+            else if (((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
+                (0, Utils_1.isInArray)("absorber", options.interactivity.events.onClick.mode)) {
+                loadAbsorbers = true;
+            }
+            return loadAbsorbers;
+        }
+        loadOptions(options, source) {
+            var _a, _b;
+            if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
+                return;
+            }
+            const optionsCast = options;
+            if (source === null || source === void 0 ? void 0 : source.absorbers) {
+                if ((source === null || source === void 0 ? void 0 : source.absorbers) instanceof Array) {
+                    optionsCast.absorbers = source === null || source === void 0 ? void 0 : source.absorbers.map((s) => {
+                        const tmp = new Absorber_1.Absorber();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    let absorberOptions = optionsCast.absorbers;
+                    if ((absorberOptions === null || absorberOptions === void 0 ? void 0 : absorberOptions.load) === undefined) {
+                        optionsCast.absorbers = absorberOptions = new Absorber_1.Absorber();
+                    }
+                    absorberOptions.load(source === null || source === void 0 ? void 0 : source.absorbers);
+                }
+            }
+            const interactivityAbsorbers = (_b = (_a = source === null || source === void 0 ? void 0 : source.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.absorbers;
+            if (interactivityAbsorbers) {
+                if (interactivityAbsorbers instanceof Array) {
+                    optionsCast.interactivity.modes.absorbers = interactivityAbsorbers.map((s) => {
+                        const tmp = new Absorber_1.Absorber();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    let absorberOptions = optionsCast.interactivity.modes.absorbers;
+                    if ((absorberOptions === null || absorberOptions === void 0 ? void 0 : absorberOptions.load) === undefined) {
+                        optionsCast.interactivity.modes.absorbers = absorberOptions = new Absorber_1.Absorber();
+                    }
+                    absorberOptions.load(interactivityAbsorbers);
+                }
+            }
+        }
+    }
+    async function loadAbsorbersPlugin(engine) {
+        const plugin = new AbsorbersPlugin();
+        await engine.addPlugin(plugin);
+    }
+    exports.loadAbsorbersPlugin = loadAbsorbersPlugin;
+});

package/umd/Plugins/Emitters/EmitterContainer.d.ts

@@ -0,0 +1,10 @@
+import type { EmitterInstance } from "./EmitterInstance";
+import type { ICoordinates } from "../../Core";
+import type { IEmitter } from "./Options/Interfaces/IEmitter";
+export interface EmitterContainer {
+    addEmitter: (options: IEmitter, position: ICoordinates) => EmitterInstance;
+    getEmitter: (idxOrName?: number | string) => EmitterInstance | undefined;
+    playEmitter: (idxOrName?: number | string) => void;
+    pauseEmitter: (idxOrName?: number | string) => void;
+    removeEmitter: (idxOrName?: number | string) => void;
+}

package/umd/Plugins/Emitters/EmitterContainer.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/Plugins/Emitters/EmitterInstance.d.ts

@@ -0,0 +1,45 @@
+import type { Container, ICoordinates, IDelta, IDimension, IHsl } from "../../Core";
+import { Emitter } from "./Options/Classes/Emitter";
+import type { Emitters } from "./Emitters";
+import type { EmittersEngine } from "./EmittersEngine";
+import type { IEmitter } from "./Options/Interfaces/IEmitter";
+import type { IEmitterSize } from "./Options/Interfaces/IEmitterSize";
+import type { RecursivePartial } from "../../Types";
+export declare class EmitterInstance {
+    #private;
+    private readonly emitters;
+    private readonly container;
+    position?: ICoordinates;
+    size: IEmitterSize;
+    options: Emitter;
+    spawnColor?: IHsl;
+    fill: boolean;
+    readonly name?: string;
+    private paused;
+    private currentEmitDelay;
+    private currentSpawnDelay;
+    private currentDuration;
+    private lifeCount;
+    private duration?;
+    private emitDelay?;
+    private spawnDelay?;
+    private readonly immortal;
+    private readonly shape?;
+    private readonly initialPosition?;
+    private readonly particlesOptions;
+    constructor(engine: EmittersEngine, emitters: Emitters, container: Container, options: RecursivePartial<IEmitter>, position?: ICoordinates);
+    externalPlay(): void;
+    externalPause(): void;
+    play(): void;
+    pause(): void;
+    resize(): void;
+    update(delta: IDelta): void;
+    getPosition(): ICoordinates | undefined;
+    getSize(): IDimension;
+    private prepareToDie;
+    private destroy;
+    private calcPosition;
+    private emit;
+    private emitParticles;
+    private setColorAnimation;
+}