tsparticles 1.40.2 → 1.41.3

package/umd/Core/Interfaces/IShapeDrawer.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/Core/Interfaces/IShapeValues.d.ts

@@ -0,0 +1,8 @@
+import type { IParticles } from "../../Options/Interfaces/Particles/IParticles";
+import type { RecursivePartial } from "../../Types";
+export interface IShapeValues {
+    close?: boolean;
+    fill?: boolean;
+    particles?: RecursivePartial<IParticles>;
+    [key: string]: unknown;
+}

package/umd/Core/Interfaces/IShapeValues.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/Core/Interfaces/index.d.ts

@@ -0,0 +1,36 @@
+export * from "./Colors";
+export * from "./Gradients";
+export * from "./IAttract";
+export * from "./IBounds";
+export * from "./IBubble";
+export * from "./IBubbleParticleData";
+export * from "./ICircleBouncer";
+export * from "./IContainerInteractivity";
+export * from "./IContainerPlugin";
+export * from "./ICoordinates";
+export * from "./IDelta";
+export * from "./IDimension";
+export * from "./IDistance";
+export * from "./IExternalInteractor";
+export * from "./IInteractor";
+export * from "./IMouseData";
+export * from "./IMovePathGenerator";
+export * from "./IParticle";
+export * from "./IParticleGradientAnimation";
+export * from "./IParticleGradientColorAnimation";
+export * from "./IParticleHslAnimation";
+export * from "./IParticlesInteractor";
+export * from "./IParticleLife";
+export * from "./IParticleLoops";
+export * from "./IParticleRetinaProps";
+export * from "./IParticleRoll";
+export * from "./IParticleSpin";
+export * from "./IParticleUpdater";
+export * from "./IParticleValueAnimation";
+export * from "./IParticleWobble";
+export * from "./IPlugin";
+export * from "./IRangeValue";
+export * from "./IRectSideResult";
+export * from "./IRepulse";
+export * from "./IShapeDrawer";
+export * from "./IShapeValues";

package/umd/Core/Interfaces/index.js

@@ -0,0 +1,58 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./Colors", "./Gradients", "./IAttract", "./IBounds", "./IBubble", "./IBubbleParticleData", "./ICircleBouncer", "./IContainerInteractivity", "./IContainerPlugin", "./ICoordinates", "./IDelta", "./IDimension", "./IDistance", "./IExternalInteractor", "./IInteractor", "./IMouseData", "./IMovePathGenerator", "./IParticle", "./IParticleGradientAnimation", "./IParticleGradientColorAnimation", "./IParticleHslAnimation", "./IParticlesInteractor", "./IParticleLife", "./IParticleLoops", "./IParticleRetinaProps", "./IParticleRoll", "./IParticleSpin", "./IParticleUpdater", "./IParticleValueAnimation", "./IParticleWobble", "./IPlugin", "./IRangeValue", "./IRectSideResult", "./IRepulse", "./IShapeDrawer", "./IShapeValues"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./Colors"), exports);
+    __exportStar(require("./Gradients"), exports);
+    __exportStar(require("./IAttract"), exports);
+    __exportStar(require("./IBounds"), exports);
+    __exportStar(require("./IBubble"), exports);
+    __exportStar(require("./IBubbleParticleData"), exports);
+    __exportStar(require("./ICircleBouncer"), exports);
+    __exportStar(require("./IContainerInteractivity"), exports);
+    __exportStar(require("./IContainerPlugin"), exports);
+    __exportStar(require("./ICoordinates"), exports);
+    __exportStar(require("./IDelta"), exports);
+    __exportStar(require("./IDimension"), exports);
+    __exportStar(require("./IDistance"), exports);
+    __exportStar(require("./IExternalInteractor"), exports);
+    __exportStar(require("./IInteractor"), exports);
+    __exportStar(require("./IMouseData"), exports);
+    __exportStar(require("./IMovePathGenerator"), exports);
+    __exportStar(require("./IParticle"), exports);
+    __exportStar(require("./IParticleGradientAnimation"), exports);
+    __exportStar(require("./IParticleGradientColorAnimation"), exports);
+    __exportStar(require("./IParticleHslAnimation"), exports);
+    __exportStar(require("./IParticlesInteractor"), exports);
+    __exportStar(require("./IParticleLife"), exports);
+    __exportStar(require("./IParticleLoops"), exports);
+    __exportStar(require("./IParticleRetinaProps"), exports);
+    __exportStar(require("./IParticleRoll"), exports);
+    __exportStar(require("./IParticleSpin"), exports);
+    __exportStar(require("./IParticleUpdater"), exports);
+    __exportStar(require("./IParticleValueAnimation"), exports);
+    __exportStar(require("./IParticleWobble"), exports);
+    __exportStar(require("./IPlugin"), exports);
+    __exportStar(require("./IRangeValue"), exports);
+    __exportStar(require("./IRectSideResult"), exports);
+    __exportStar(require("./IRepulse"), exports);
+    __exportStar(require("./IShapeDrawer"), exports);
+    __exportStar(require("./IShapeValues"), exports);
+});

package/umd/Core/Loader.d.ts

@@ -0,0 +1,32 @@
+import { Container } from "./Container";
+import type { Engine } from "../engine";
+import type { IOptions } from "../Options/Interfaces/IOptions";
+import type { Particle } from "./Particle";
+import type { RecursivePartial } from "../Types";
+import type { SingleOrMultiple } from "../Types";
+interface LoaderParams {
+    element?: HTMLElement;
+    index?: number;
+    options?: SingleOrMultiple<RecursivePartial<IOptions>>;
+    tagId?: string;
+}
+interface RemoteLoaderParams {
+    element?: HTMLElement;
+    index?: number;
+    tagId?: string;
+    url?: SingleOrMultiple<string>;
+}
+export declare class Loader {
+    #private;
+    constructor(engine: Engine);
+    dom(): Container[];
+    domItem(index: number): Container | undefined;
+    loadOptions(params: LoaderParams): Promise<Container | undefined>;
+    loadRemoteOptions(params: RemoteLoaderParams): Promise<Container | undefined>;
+    load(tagId: string | SingleOrMultiple<RecursivePartial<IOptions>>, options?: SingleOrMultiple<RecursivePartial<IOptions>> | number, index?: number): Promise<Container | undefined>;
+    set(id: string | HTMLElement, domContainer: HTMLElement | SingleOrMultiple<RecursivePartial<IOptions>>, options?: SingleOrMultiple<RecursivePartial<IOptions>> | number, index?: number): Promise<Container | undefined>;
+    loadJSON(tagId: string | SingleOrMultiple<string>, jsonUrl?: SingleOrMultiple<string> | number, index?: number): Promise<Container | undefined>;
+    setJSON(id: string | HTMLElement, domContainer: HTMLElement | SingleOrMultiple<string>, jsonUrl: SingleOrMultiple<string> | (number | undefined), index?: number): Promise<Container | undefined>;
+    setOnClickHandler(callback: (evt: Event, particles?: Particle[]) => void): void;
+}
+export {};

package/umd/Core/Loader.js

@@ -0,0 +1,193 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+(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", "./Container", "../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var _Loader_engine;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Loader = void 0;
+    const Utils_1 = require("./Utils");
+    const Container_1 = require("./Container");
+    const Utils_2 = require("../Utils");
+    function fetchError(statusCode) {
+        console.error(`Error tsParticles - fetch status: ${statusCode}`);
+        console.error("Error tsParticles - File config not found");
+    }
+    class Loader {
+        constructor(engine) {
+            _Loader_engine.set(this, void 0);
+            __classPrivateFieldSet(this, _Loader_engine, engine, "f");
+        }
+        dom() {
+            return __classPrivateFieldGet(this, _Loader_engine, "f").domArray;
+        }
+        domItem(index) {
+            const dom = this.dom();
+            const item = dom[index];
+            if (item && !item.destroyed) {
+                return item;
+            }
+            dom.splice(index, 1);
+        }
+        async loadOptions(params) {
+            var _a, _b, _c;
+            const tagId = (_a = params.tagId) !== null && _a !== void 0 ? _a : `tsparticles${Math.floor(Math.random() * 10000)}`;
+            const { options, index } = params;
+            let domContainer = (_b = params.element) !== null && _b !== void 0 ? _b : document.getElementById(tagId);
+            if (!domContainer) {
+                domContainer = document.createElement("div");
+                domContainer.id = tagId;
+                (_c = document.querySelector("body")) === null || _c === void 0 ? void 0 : _c.append(domContainer);
+            }
+            const currentOptions = options instanceof Array ? (0, Utils_2.itemFromArray)(options, index) : options;
+            const dom = this.dom();
+            const oldIndex = dom.findIndex((v) => v.id === tagId);
+            if (oldIndex >= 0) {
+                const old = this.domItem(oldIndex);
+                if (old && !old.destroyed) {
+                    old.destroy();
+                    dom.splice(oldIndex, 1);
+                }
+            }
+            let canvasEl;
+            if (domContainer.tagName.toLowerCase() === "canvas") {
+                canvasEl = domContainer;
+                canvasEl.dataset[Utils_1.Constants.generatedAttribute] = "false";
+            }
+            else {
+                const existingCanvases = domContainer.getElementsByTagName("canvas");
+                if (existingCanvases.length) {
+                    canvasEl = existingCanvases[0];
+                    canvasEl.dataset[Utils_1.Constants.generatedAttribute] = "false";
+                }
+                else {
+                    canvasEl = document.createElement("canvas");
+                    canvasEl.dataset[Utils_1.Constants.generatedAttribute] = "true";
+                    canvasEl.style.width = "100%";
+                    canvasEl.style.height = "100%";
+                    domContainer.appendChild(canvasEl);
+                }
+            }
+            const newItem = new Container_1.Container(__classPrivateFieldGet(this, _Loader_engine, "f"), tagId, currentOptions);
+            if (oldIndex >= 0) {
+                dom.splice(oldIndex, 0, newItem);
+            }
+            else {
+                dom.push(newItem);
+            }
+            newItem.canvas.loadCanvas(canvasEl);
+            await newItem.start();
+            return newItem;
+        }
+        async loadRemoteOptions(params) {
+            const { url: jsonUrl, index } = params;
+            const url = jsonUrl instanceof Array ? (0, Utils_2.itemFromArray)(jsonUrl, index) : jsonUrl;
+            if (!url) {
+                return;
+            }
+            const response = await fetch(url);
+            if (!response.ok) {
+                fetchError(response.status);
+                return;
+            }
+            const data = await response.json();
+            return this.loadOptions({
+                tagId: params.tagId,
+                element: params.element,
+                index,
+                options: data,
+            });
+        }
+        load(tagId, options, index) {
+            const params = { index };
+            if (typeof tagId === "string") {
+                params.tagId = tagId;
+            }
+            else {
+                params.options = tagId;
+            }
+            if (typeof options === "number") {
+                params.index = options !== null && options !== void 0 ? options : params.index;
+            }
+            else {
+                params.options = options !== null && options !== void 0 ? options : params.options;
+            }
+            return this.loadOptions(params);
+        }
+        async set(id, domContainer, options, index) {
+            const params = { index };
+            if (typeof id === "string") {
+                params.tagId = id;
+            }
+            else {
+                params.element = id;
+            }
+            if (domContainer instanceof HTMLElement) {
+                params.element = domContainer;
+            }
+            else {
+                params.options = domContainer;
+            }
+            if (typeof options === "number") {
+                params.index = options;
+            }
+            else {
+                params.options = options !== null && options !== void 0 ? options : params.options;
+            }
+            return this.loadOptions(params);
+        }
+        async loadJSON(tagId, jsonUrl, index) {
+            let url, id;
+            if (typeof jsonUrl === "number" || jsonUrl === undefined) {
+                url = tagId;
+            }
+            else {
+                id = tagId;
+                url = jsonUrl;
+            }
+            return this.loadRemoteOptions({ tagId: id, url, index });
+        }
+        async setJSON(id, domContainer, jsonUrl, index) {
+            let url, newId, newIndex, element;
+            if (id instanceof HTMLElement) {
+                element = id;
+                url = domContainer;
+                newIndex = jsonUrl;
+            }
+            else {
+                newId = id;
+                element = domContainer;
+                url = jsonUrl;
+                newIndex = index;
+            }
+            return this.loadRemoteOptions({ tagId: newId, url, index: newIndex, element });
+        }
+        setOnClickHandler(callback) {
+            const dom = this.dom();
+            if (dom.length === 0) {
+                throw new Error("Can only set click handlers after calling tsParticles.load() or tsParticles.loadJSON()");
+            }
+            for (const domItem of dom) {
+                domItem.addClickHandler(callback);
+            }
+        }
+    }
+    exports.Loader = Loader;
+    _Loader_engine = new WeakMap();
+});

package/umd/Core/Particle.d.ts

@@ -0,0 +1,71 @@
+import { ShapeType } from "../Enums";
+import type { IBubbleParticleData, ICoordinates, ICoordinates3d, IDelta, IHsl, IParticle, IParticleGradientAnimation, IParticleHslAnimation, IParticleLife, IParticleNumericValueAnimation, IParticleRetinaProps, IParticleRoll, IParticleSpin, IParticleTiltValueAnimation, IParticleValueAnimation, IParticleWobble, IRgb, IShapeValues } from "./Interfaces";
+import { Vector, Vector3d } from "./Utils";
+import type { Container } from "./Container";
+import type { Engine } from "../engine";
+import type { IParticles } from "../Options/Interfaces/Particles/IParticles";
+import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions";
+import type { RecursivePartial } from "../Types";
+import type { Stroke } from "../Options/Classes/Particles/Stroke";
+export declare class Particle implements IParticle {
+    #private;
+    readonly id: number;
+    readonly container: Container;
+    readonly group?: string | undefined;
+    destroyed: boolean;
+    lastPathTime: number;
+    misplaced: boolean;
+    spawning: boolean;
+    splitCount: number;
+    unbreakable: boolean;
+    readonly pathDelay: number;
+    readonly sides: number;
+    readonly options: ParticlesOptions;
+    readonly life: IParticleLife;
+    roll?: IParticleRoll;
+    wobble?: IParticleWobble;
+    backColor?: IHsl;
+    close: boolean;
+    fill: boolean;
+    randomIndexData?: number;
+    gradient?: IParticleGradientAnimation;
+    rotate?: IParticleValueAnimation<number>;
+    tilt?: IParticleTiltValueAnimation;
+    color?: IParticleHslAnimation;
+    opacity?: IParticleNumericValueAnimation;
+    strokeWidth?: number;
+    stroke?: Stroke;
+    strokeColor?: IParticleHslAnimation;
+    readonly moveDecay: number;
+    readonly direction: number;
+    readonly position: Vector3d;
+    readonly offset: Vector;
+    readonly shadowColor: IRgb | undefined;
+    readonly size: IParticleNumericValueAnimation;
+    readonly velocity: Vector;
+    readonly shape: ShapeType | string;
+    readonly spin?: IParticleSpin;
+    readonly initialPosition: Vector;
+    readonly initialVelocity: Vector;
+    readonly shapeData?: IShapeValues;
+    readonly bubble: IBubbleParticleData;
+    readonly zIndexFactor: number;
+    readonly retina: IParticleRetinaProps;
+    constructor(engine: Engine, id: number, container: Container, position?: ICoordinates, overrideOptions?: RecursivePartial<IParticles>, group?: string | undefined);
+    isVisible(): boolean;
+    isInsideCanvas(): boolean;
+    draw(delta: IDelta): void;
+    getPosition(): ICoordinates3d;
+    getRadius(): number;
+    getMass(): number;
+    getFillColor(): IHsl | undefined;
+    getStrokeColor(): IHsl | undefined;
+    destroy(override?: boolean): void;
+    reset(): void;
+    private split;
+    private calcPosition;
+    private checkOverlap;
+    private calculateVelocity;
+    private loadShapeData;
+    private loadLife;
+}